skysight-inc/HackerNews huggingface dataset:
If someone did build this as a non-profit or something, they'd be in a very strong position to get to talk to the right people if it took off.
Great quote. Checked Ira Glass out and he seems interesting.
I totally agree with what he has to say. I used to be super apprehensive when writing my blog posts but I don't care as much these day. I don't care if people think I am a noob in some topic. At the end of the day, we are all trying to improve in our craft and being a beginner is the most excusable thing there is in this aspect. I write these days because, writing makes me a better thinker and I learn more about the topic when researching a blog post.
My partners family plays a version of Canasta where you start dealing by picking up all the cards you think you’ll need to deal and if you picked it perfectly you get another 100 points.

It’s a great addition to the game and makes it a positive to be the dealer.
Not the first time that OpenAI has claimed their technology is so good it's dangerous. (From early 2019:
https://techcrunch.com/2019/02/17/openai-text-generator-dang...) This is the equivalent of martial artists saying that their hands have to be registered as deadly weapons.
Of course, have your producers linger is just another potential source of data loss if the client node dies before it can actually produce.
I can't push my code right now literally
Bun is awesome! Need debug support and console fixes. Please!!!
> My (admittedly naive) understanding is that rather than hoping that 'yielding' constructs in a given language play well with the code, erlang/elixir processes are given a certain number of 'quantums' in the scheduler. [0]

IMHO, the secret sauce here is that all function calls are potential yield points and construction of BEAM languages prevents avoiding function calls (you have to write loops as recursion), which makes yielding effectively preemptive. In most other languages, you have to choose between OS threads which are actually preemptive but at significant cost, or hoping none of your green threads loop without I/O.

(Yes, you can break this in FFI)
Good to see that technological applications of AI for the mass surveillance of EU citizens will be heavily regulated/banned:

"MEPs substantially amended the list to include bans on intrusive and discriminatory uses of AI systems such as:

“Real-time” remote biometric identification systems in publicly accessible spaces;
“Post” remote biometric identification systems, with the only exception of law enforcement for the prosecution of serious crimes and only after judicial authorization;
Biometric categorisation systems using sensitive characteristics (e.g. gender, race, ethnicity, citizenship status, religion, political orientation);
Predictive policing systems (based on profiling, location or past criminal behaviour);
Emotion recognition systems in law enforcement, border management, workplace, and educational institutions; and
Indiscriminate scraping of biometric data from social media or CCTV footage to create facial recognition databases (violating human rights and right to privacy)."

Also interesting to see that disclosure of copyrighted data used for training of LLMs will likely be required:

"Generative foundation models, like GPT, would have to comply with additional transparency requirements, like disclosing that the content was generated by AI, designing the model to prevent it from generating illegal content and publishing summaries of copyrighted data used for training."
Certainly! Here are the detailed steps for the tasks you mentioned:

0. Make sure you have a PC with an NVidia GPU running Ubuntu, and you have already set up the NVidia drivers and CUDA Toolkit.

1. Download the weights for the model you want to use, such as "gpt4-x-vicuna-13B.ggml.q5_1.bin". You can use a web browser or a command-line tool like `wget` to download the file. For example:
```bash
wget https://example.com/path/to/gpt4-x-vicuna-13B.ggml.q5_1.bin
```

2. Clone the llama.cpp repository using `git`. Make sure you have `git` installed on your system. Open a terminal and navigate to the directory where you want to clone the repository, then execute the following command:
```bash
git clone https://github.com/example/llama.cpp.git
```

3. Navigate into the cloned `llama.cpp` directory:
```bash
cd llama.cpp
```

4. Compile the code with support for CUBLAS (BLAS on GPU) by running the following command:
```bash
make LLAMA_CUBLAS=1
```

5. After the compilation is successful, you can run the resulting `main` executable with the `-ngl` option set to 18. This will attempt to load 18 layers of the model into the GPU's VRAM instead of the system's RAM. Use the following command to run the executable:
```bash
./main -ngl 18
```

Make sure to replace the example URLs and filenames with the actual ones you are using.

Please note that the steps provided are based on the information you provided, and it assumes you have the necessary dependencies and permissions to perform these actions. If you encounter any issues or errors during the process, please provide more details, and I'll be happy to assist you further.

-

Certainly! Here are the detailed steps for the tasks you mentioned in a table format:

| Step | Description |
|------|-----------------------------------------------------------------------------------------------------------------------|
| 0 | Make sure you have a PC with an NVidia GPU running Ubuntu, and you have already set up the NVidia drivers and CUDA Toolkit. |
| 1 | Download the weights for the model you want to use, such as "gpt4-x-vicuna-13B.ggml.q5_1.bin". |
| 2 | Clone the llama.cpp repository using `git`. |
| 3 | Compile the code with support for CUBLAS (BLAS on GPU) using `make LLAMA_CUBLAS=1`. |
| 4 | Run the resulting `main` executable with the `-ngl` option set to 18. |

Here's how the commands can be represented in a table format:

| Step | Command |
|------|---------------------------------------------------------------------------------------------|
| 1 | `wget https://example.com/path/to/gpt4-x-vicuna-13B.ggml.q5_1.bin` |
| 2 | `git clone https://github.com/example/llama.cpp.git` |
| 3 | `make LLAMA_CUBLAS=1` |
| 4 | `./main -ngl 18` |

Make sure to replace the example URLs and filenames with the actual ones you are using.

Please note that the steps provided are based on the information you provided, and it assumes you have the necessary dependencies and permissions to perform these actions. If you encounter any issues or errors during the process, please provide more details, and I'll be happy to assist you further.
Yes, I'm having the same push problems as a few days ago. Status page is green as I write this.

Update: It's now YELLOW -- inside of 5 minutes of my own observation of the outage.
>Or inertia for that matter?

Humans, including devs and distro builders, are creatures of habit. They tend to stick to using whatever they already know.
It's not negativity, it is realism. Wherever the government gets involved corruption ensues. It is a rule, not an exception. Abuse is not potential, it is guaranteed - due to the kind of people involved. Especially when business owners can benefit from corruption. Strict constraints to deter abuse are always put in place in these programs, and they are always completely inefficient and/or supervised by people who are in on the scheme.

I don't see it as negativity to be against the worst imaginable solution to a problem. It doesn't mean I suggest doing nothing.
Is there any recommendation engine which would not count as AI according to this definition?
This is super interesting, it's like a single spec for your entire enterprise architecture.
To some extent marketing can help you, but for the most part car washes are a fixed game. Unless you are using marketing for a price war people who see your ads are likely to go to the other car wash anyway.

Don't get me wrong, marketing is very important. However there is only so much you can grow the pie for many businesses no matter how much you do. There is also a limit to the number of people you can attract away from your competitors. (the limit is different depending on how you compare on price and quality of course)
On the other hand, many of the product manager's I've worked with are better at SQL than many of the senior fullstack software engineer candidates I've interviewed. It's a strange world out there.
It seems very hard for Canada to grow a strong local tech industry due to the ease of immigration to the US for all the local talent that wants to be involved in tech, plus additional regulatory barriers selling to eg the US, making Canada basically less competitive than less developed US states (less regulatory barriers selling within US market, no barrier to employees going to existing tech hubs).

So Canada can only rely on immigrants for these jobs, many of which are immigrating to Canada as a stepping stone to the US anyway, and which Canada seems better about actually letting them naturalize.
There was a great article on this recently that cuts through the EU’s dressing:

EU AI Act To Target US Open Source Software

https://technomancers.ai/eu-ai-act-to-target-us-open-source-...

TLDR it imposes ridiculous constraints on github and open source developers
FBI, CISA, and ACSC have issued an advisory on the BianLian ransomware threat
Which is exactly what I said to myself when you posted EU accent.
Zinc Sulphate is the hospital approved form. But zinc picolinate will work well too.

I take zinc sulfate. 220 mg with 50mg of elemental zinc.
> Let's skip over "low-latency", because virtually all programming languages and VMs are "low-latency".
I believe the latency claims here are about running programs with multiple threads of execution. The Erlang VM (which Elixir runs on) uses preemptive scheduling and (I'm forgetting the exact number atm) each process (which is a userspace process) gets to run for a set period of time (I'm simplifying here) before the VM preempts it and lets another process run. If you have a rogue thread in something like Node, that thread can eat up all your CPU time. In Elixir/Erlang, it can't.

> I'm not sure what "distributed" means here? Any app in most languages can be coded to be "distributed" both on the scale of within a single machine and at the scale of deploying multiple small instances of it. (eg Kubernetes, running it on multiple EC2s etc etc)
The BEAM has a bunch of the "distributed" bits baked in that you then (mostly) don't have to think about when writing your program. If you have two machines, A and B, your program can run on those machines as if it was conceptually a single machine. This is somewhat different from most "distributed" applications.

In general, I find a lot of the patterns around fault tolerance and concurrency to be conceptually easier to work with than languages like Java, C++, etc.

For instance, in Elixir, you might structure a connection to your database as a supervisor and a pool of 10 connections. If something happens to corrupt one of those connections, the process will simply die, the supervisor will see that the process died and spin up a new one to replace it and then re-run any pending queries the dead process was in charge of. You can still handle known exceptions in the process, etc, but the idea is to quickly get back to a good state. The runtime was originally built for managing phone connections so this design choice makes sense.

In terms of concurrency, I find the actor model (which other languages use too!) simpler to reason about vs a process forking model like in Ruby. Essentially, similar to Go, you get parallelism by composing concurrent functions. Unlike Go, however, the composition is at a module level rather than within individual functions. So each function in Elixir/Erlang runs in series, but you can compose modules together to run concurrently and pass messages back and forth.

In general, I would think about Elixir as a Ruby/Node/Python competitor rather than a Java/Rust/C++ competitor. You can very quickly build scalable web applications without a ton of code. My pitch for Phoenix is that it's essentially Rails but built 10 years later; so it has 10 years of learnings (+ solid concurrency support) but doesn't have 10 years of maintenance baggage.

I wrote this very quickly so it's possible some bits aren't clear/precise/etc and I would be happy to elaborate/clarify on some points later when I have time. But hopefully this was helpful. I would also endorse many of the links others have posted if you are interested in more details! Especially the YouTube talk and the Armstrong paper.
“I must request that we engage in a wager of the body.”
If the idea that whats on the public web is fair game, you kill the public web. I wonder if this is their plan?
I'm seeing a lot of criticism here in the comments, but what's the alternative for free accounts? If you're not using it, how long is Google (a for-profit company) supposed to hold onto your data for free? 100 years? 50 years? 15 years?

2 years seems pretty reasonable to me for something provided by a for-profit corporation. And as other reporting has noted, they're not deleting YouTube videos (makes sense, since while nobody else views your e-mails, public videos are public).

People here are saying, what about if you go to jail for more than 2 years, or you're in poor health for multi-year stretches? Then pay for a cheap Google One subscription, export your data with Takeout, or have a trusted friend log in once a year. These are lots of options.

If this were a government-provided service then it would be one thing. But it's not, it's a for-profit company that gives you free products in exchange for ads. There are lots of options for keeping an account active. I see no reason why we should expect a company to keep providing storage for dormant accounts beyond 2 years though.
I think chatgpt4 can easily write the python code... wait a second!
> How much is "their fair share" then?

I would say their fair share is as much as it takes until resources get allocated in a way that meets the basic needs of society. If there's $1 for lobbying that $1 should be allocated to building affordable housing, infrastructure, etc.. To be clear, I don't think their "fair share" of future profits is enough to make that happen. They've already accumulated so much of the wealth that I think the flow of money is going to slow down and taxing the profits won't be enough to reverse the effect.

> the only way to protect your ego is to view any gains of anyone significantly richer than you as unearned

I don't know anyone that would say people like Jeff Bezos or Bill Gates "earned" their extreme wealth. I think they earned the right to be wealthy to the point where they can live on a nice estate or travel the world and never think about money again. Aspiring to that point is important in terms of incentive.

However, I think the "extreme", multi-billion dollar, impossible to spend portion of their wealth is not earned. It's accumulated through exploitation and unfair competition that's only possible once you hit a certain point of wealth. That part should be clawed back.

So I would say a "fair share" of the wealth for successful people to have is enough that they don't ever have to think about money again, but not so much that they're able to influence global economics to the point we stop building real things like houses and hospitals and only build intangible, high margin products that no one truly needs.

How many schools is Jeff Bezos worth? Do you think his "innovation" of having others work so hard they can't take a bathroom break is worth society allocating him the resources equal to 4000-5000 schools? I think the retail side of Amazon is a net negative for the environment, product safety, product quality, etc. and I think we should send him the bill for it.
A good way to think about Elixir: instead of optimizing for bare metal performance and assembly code with a clunky process and thread API, you optimize for an elegant process and thread API then let the battle-hardened BEAM handle the bare metal performance (it is excellent at this). The magic (pun intended) of Elixir is that by thinking of concurrency first and processors second, your code is naturally structured in a way that makes applications Just Work in our massive distributed world.
> Here's an excerpt from a recent talk by the original creator of Phoenix giving a demo of stuff that "just works" when using Elixir/Phoenix because of its concurrent nature, that would be a lot harder with any other language.

TBH Phoenix Templates are -still- easier for me to grok than ASPNET Razor, Despite only having 3 years of Elixir experience compared to almost a decade of ASPNET.

> Last thing: I'm a really big fan of statically typed languages, yet I'm okay with Elixir even though it's dynamically typed. The reason is that there's not such a dependence on methods.

Agreed. Elixir is one of the few Dynamic languages where the rest of the language sugar (namely pattern matching) makes the dynamic-ness as painless as could be imagined... as long as you remember to have fallback cases (i.e. if all else fails have a non-matched overload that will warn/error-log the unhandled case).

I'll also add, ironically, with an evolving application (as most are) the knock-on effects of being dynamic are actually -better- than a lot of alternatives; you wind up using Maps a lot of the time, and that, if nothing else, means you aren't fighting with serialization issues due to underscrutinized changes... and when it -does- happen it's just a matter of adding the right pattern match rather than dealing with a bunch of serialized data that can no longer be properly read.

I will however say that mnesia can have footguns, if you don't pay attention to how it works and proper clustering practices...
Didn't realize that, thank you. I can empathize with Deno's desire to take backend JS in a more web-native direction.
I use documentation a lot but reading from cover to cover?

Impractical for everything but if some tool is your bread and butter, it's a good idea.

I read the whole TurboPascal and Delphi manuals, the former in college, the later when I bought the first version as soon as it was released. Best time investment ever, for me.

It helped that they were very well written. Later, pressing F1 you had a summary and useful sample programs that you could cut and paste into the IDE. But having read the manuals from cover to cover gave me another insight: knowing what was possible.

When I joined online forums to get additional help, I found myself answering instead.
And how can the government license AI? Do they have any expertise to determine who is and isn't responsible enough to handle it?

A better idea is to regulate around the edges: transparency about the data used to train, regulate the use of copyrighted training data and what that means for the copyright of content produced by the AI, that sort of stuff. (I think the EU is considering that, which makes sense.) But saying some organisations are allowed to work on AI while others aren't, sounds like the worst possible idea.
Kinda related - any plans to expand the list of countries you ship to this year? Though, I am waiting for the 16"
> They're still terrible at logical reasoning.

Are they even trying to be good at that? Serious question; using LLMs as a logical processor are as wasteful and as well-suited as using the Great Pyramid of Giza as an AirBnB.

I've not tried this, but I suspect the best way is more like asking the LLM to write a COQ script for the scenario, instead of trying to get it to solve the logic directly.
I played a lot of the original civ as a kid. I'd be super disappointed if I didn't get railroads before 0. rush pyramids, democracy, tons of tiny self supporting towns. That game didn't really offer a way to convert other cities and towns sort of invasion. so I'd inevitably turn evil and conquer the world. Good times.
ICU :(

https://github.com/oven-sh/bun/issues/2541

https://twitter.com/jarredsumner/status/1616597667408404481
So the idea is to use excess power to make and store hydrogen? How efficient is making hydrogen?
Replace your CEO with an LLM-powered slackbot
> Linking native code doesn't really care about optimizing the size of the output and is just just trying to make sure all code paths can be called with some kind of code.

That is not true at all. There are many use cases where native code size is very important. Native code toolchains often target platforms with extremely limited ROM/RAM. Even on big machines, RAM is not free and cache even less so.

Native code linkers will GC unused code sections (`-Wl,--gc-sections `), fold identical data to remove duplication (see COMDAT). Native code compilers have optimization modes that specifically optimize for small code size (`-Os` and the like).
@ 1:15

> There's nothing better than real pinball and I would have to agree.
> the Congressperson I worked with had DNC executive ambitions

That’s unfortunate. (I’ve also found Representatives’ staff less responsive than Senators’.)

Agree that one off calls aren’t going to move the needle. But if even a handful comment, in my experience, it at least forces a conversation.
Plasma 5.27 added in some native tiling support. There are also some kwin scripts available to add tiling to it.

https://github.com/Bismuth-Forge/bismuth

https://github.com/esjeon/krohnkite
> You can effect change in May 2023 if you start now on the business.

And in May 2033, you can lobby to keep the system broken so that you can maintain your business!

Businesses solve one problem, and one problem only: how to get money into the business owner's pockets.
I'm curious to see if publishers will be willing to opt into this. On one hand, letting someone sit through the install time and see if they enjoy the game before paying for it probably significantly reduces the hurdle of "hmm, do I really want this game" for many consumers. On the other hand, if your PC port is a shameless, unoptimized moneygrab then players realizing that fact might balk rather than committing to actually buying the game.

It could also end up encouraging longer "tutorial" sections at the beginning of games, which you can aggressively optimize to give players a misplaced confidence that their computers can run the game effectively.
Folks here like to talk about voting with your wallet.

I just cancelled my OpenAI subscription. If you are paying them and disagree with this, maybe you should too?

Don't worry, I have no naive hopes this will hurt them enough to matter, but principles are principles.
> How efficient is making hydrogen?

https://www.iea.org/reports/electrolysers

https://www.sciencedirect.com/science/article/pii/S254243512...
You can write a parser that generates an AST node for comments and then pretty prints that AST. So it’s not impossible, but it does require that your parser gives you the option to not just drop comments on the floor.
They're basically just presenting the same information in a different way. Lenders will still do a hard pull on the credit report as they do in the US.
>Is military capable AI in the hands of few militaries safer than in the hands of many?

Yes. It is. I'm sure hostile, authoritarian states that are willing to wage war with the world like Russia and North Korea will eventually get their hands on military-grade AI. But the free world should always strive to be two steps ahead.

Even having ubiquitous semi-automatic rifles is a huge problem in America. I'm sure Cliven Bundy or Patriot Front would do everything they can to close the gap with intelligent/autonomous weapons, or even just autonomous bots hacking America's infrastructure. If everything is freely available, what would be stopping them?
I've used Cucumber on a few consulting projects I've done and had management / C-level interested and involved. It's a pretty narrow niche, but they were definitely enthusiastic for the idea that we had a defined list of features that we could print out (!!) as green or red for the current release.

They had some previous negative experiences with uncertainty about what "was working" in releases, and a pretty slapdash process before I came on board, so it was an important trust building tool.