skysight-inc/HackerNews huggingface dataset:
> Rust literally has none of these mechanisms and likely never will

It's true that Rust has no stable ABI, but "likely never will" is hyperbole. If people demand it in sufficient quantity then it will happen in time. I personally hope it does someday, but I'm in no hurry.

> There's a reason C++ names look like CintFuncf!!!@34$902, Rust doesn't have or plan to have anything like this yet, and it'd need to be 20x more complicated.

Rust does have name mangling already. It may not be standardized (again, no stable ABI), but C++'s name mangling isn't standardized either. And I see no justification for why name mangling in Rust would need to be "20x more complicated" than in C++; AFAIK Rust symbols pretty much already imitate C++ symbols in order to play nicely with existing tooling.

This would be more informative if you gave some concrete examples. Any hypothetical Rust ABI would be more extensive than the de facto C ABIs, undoubtedly, but the concern here seems unjustified.
Aren't you talking about criminal rather than civil law?
Coredumps and debuggers are a thing. Sounds more like a bad TA.
How to WIN IN CLUTCH 1 ON 1 – CS:GO GUIDES AND TIPS
This problem needs to be fixed with education. The article demonstrates an extremely profound misunderstanding of technology.
Breaking up with higher order components
> harvest every joule produce by the sun and use it to calculate hashes.

Paperclipping - https://wiki.lesswrong.com/wiki/Paperclip_maximizer
> I'm pretty sure it would. Why do you think it would not?

Languages like Coq require you to prove a function halts before it will compile. Yes, for an arbitrary function it can be arbitrarily difficult or impossible to prove termination. In most cases though, termination proofs aren't that complex (e.g. "it halts because the collection gets smaller each recursive call").

Besides, you're argument is basically sounding like "because you can't prove all functions halt it's a waste of time proving any functions halt". See the sel4 OS for an impressive example of what formal proofs can do.
Most of it is self-explanatory but still, could you give some examples of things you recently learning while applying these points.
Well, you get what you pay for. Rust can call and expose C-style ABI functions natively so you can always do what C does. If you want a safer Rust API you can also have that but it makes interfacing with 3rd party code more difficult.

I disagree somewhat with your assertion that:

> C embeds a remarkable amount of cross-object-file information about a function just with 'int f();'. We know the range of valid values, we know how big the object is, etc.".

First of all this is not embedded in the object file but rather in the header, Rust doesn't need that. The object only tells you the name of the symbol and that's about it. In particular that means that the C linker can't detect ABI mismatch if the prototype of a function or the layout of a struct changed, as long as the symbol is found it'll link just fine.

Furthermore even with the header available a lot of the time C prototypes are not sufficient to know how to use a method. Take for instance:

sometype_t *some_function(someothertype_t *param, int flag);

Is param an input or output parameter? Do I own the return value or is it allocated by the function? Or maybe it's just a member of param so it has the same lifetime? I know that flag is an int but that doesn't really tell me which are the valid values I can put in there. In Rust function signatures tell you all of that and it's enforced by the compiler.

So yeah, there's a significant overhead in Rust here, but it's for a good reason IMO. It does make it harder to make quick hacks with the linker though.

> There's a reason C++ names look like CintFuncf!!!@34$902, Rust doesn't have or plan to have anything like this yet, and it'd need to be 20x more complicated.

Are you talking about name mangling? Rust does that too but that's not really the same issue, it's just about generating unique "flat" names for objects that include namespacing and generic info. Like if you have a "fn foo<T>(t: &T)" and you instanciate it with T = i32 and T = String you need to generate two symbols. C doesn't need that because it doesn't have namespaces, generics or overloading.
gcc does it precisely because the C standard says that it can do so

Or rather, because the standard "imposes no requirements". A compiler that does the obvious/sensible thing for UB can also claim conformance.

From C99 3.4.3 paragraph 3 (emphasis mine): "Possible undefined behavior ranges from ignoring the situation completely with unpredictable results, to behaving during translation or program execution in a documented manner characteristic of the environment (with or without the issuance of a diagnostic message), to terminating a translation or execution (with the issuance of a diagnostic message)."
We collect 60mL, less than 10% of what may be drawn in a bone marrow donation by this method, of which there are no known deleterious effects. Our physicians suggest you take it easy for a day or so, but aside from a tender spot, recovery is almost immediate.
I tend to use Amazon Workspaces for this. It's a joy to work with(especially now it supports two screens). Having a desktop that is exactly the same wherever I am doesn't sound like much but is one of those small things that you really miss when it's gone. I'm not aware of any other providers, though I'm sure there are 1000s. One nice advantage of Workspaces is that it integrates with Amazon AD out of the box.
Why Does PUNCHING Sonic 3D Trigger a Secret Level Select?
Has the average person heard of 4-chan? If they had, would they understand it as anything different to Facebook, which they seem to trust, or the comments section under a news story, ditto?

People don’t know what accurate and trustworthy looks like. Even when things are labeled as fiction, they can have an effect - Scotish Independence became more popular when the film “Braveheart” was released, while Islamophobia went up after “American Sniper” was released. Or am I just repeating plausible but fictional urban legends that I’ve mistaken for reality?
And to be honest modern C99 stuff do not solve the fundamental problems in C (and solving those gives you something that is not C)

(some of the changes) http://www.open-std.org/jtc1/sc22/wg14/www/newinc9x.htm
It taking "ramanujan" and not "ramanujan-hardy" put me off it
In most cases, you cannot. Cells that are not your own are cleared from the body or rejected in a short time.
Its how the local hospital here is cooled during the summer.
Large pile of snow which is covered in wood chips.
Apparently it generated 1345,3 MWh cooling energy in 2002..

http://www.snowpower.se/sundsvalls-kylanlaggning_en.asp
Contrarily, had we 'switched to something much "safer" a long time ago', then by now--out of sheer necessity--we may have been adept at leveraging economics and politics to make hardware user-hackable. As it is we could just be using the swiss-cheese safety of C as a crutch to avoid having to tackle the hard social problems of getting people to care about liberated devices.
It absolutely is. The culmination of the "why" section is basically "because you will run a business better":

"In any competitive field, you can win big by seeing things that others daren't. And in every field there are probably heresies few dare utter. Within the US car industry there is a lot of hand-wringing now about declining market share. Yet the cause is so obvious that any observant outsider could explain it in a second: they make bad cars. And they have for so long that by now the US car brands are antibrands—something you'd buy a car despite, not because of. Cadillac stopped being the Cadillac of cars in about 1970. And yet I suspect no one dares say this. [11] Otherwise these companies would have tried to fix the problem."
Prototypes are far bettered suited with Postgres or Mysql on RDS. When you don't know your schema or your use case upfront, traditional databases are far easier to work with, since you can change them. Once you know what your doing scaling up works far better on something like Dynamo or Cassandra, but you will be sacrificing dev time
Outside of the body in culture? They do seem to age if grown for very long periods of time. This is why we cryopreserve them, it essentially freezes them in time.
Quantum Weirdness Once Again Shows We're Not Living in a Computer Simulation
>OTOH, if you're using "codebase of significant size" as code for "big ball of mud", static typing certainly helps, but integration tests are the real lifesaver

No. I mean when the codebase is of a certain size, new features require some thought and planning. Features may span multiple-modules. They may require partial or full rewrites or the refactoring of any number of sub-components to support the new behaviour. This means that you proceed carefully because you may not want to introduce regression bugs. This costs time. At that point, you're not limited by your typing speed as you may be putting in net 10 lines of code a day. There is just no benefit to dynamic typing at that point. Worse for dynamic languages, this is where improved tooling and static type constraints start paying extreme dividends.
Ah, it's basically an easier way to do FaaS? I read "first-class citizens of your development environment" to mean it's purpose is run your code on another machine for your own benefit.

It's interesting. (I don't like JS for backend work so I'm not your target market.)
http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf is the draft of the C11 spec,

3.4.3 undefined behavior

behavior, upon use of a nonportable or erroneous program construct or of erroneous data,
for which this International Standard imposes no requirements

NOTE Possible undefined behavior ranges from ignoring the situation completely with unpredictable
results, to behaving during translation or program execution in a documented manner characteristic of the environment (with or without the issuance of a diagnostic message), to terminating a translation or execution (with the issuance of a diagnostic message).

-------------

Even if you want to argue over what "imposes no requirements" means, I'd argue that "ignoring the situation completely with unpredictable results" is very clear.

The note also says (and elsewhere in the standard it reinforces this) that since there are no requirements, implementations could absolutely do things like perform runtime checks, etc. Compilers do not do this though. This isn't for no reason, but that's a separate issue.
Will London monetise Metro passengers mobility data
How reports from 4chan on the Las Vegas shooting showed up on Google Top Stories
I have serious doubts that anybody would actually create such a language. The basic problem with C is the ease in which you're allowed to shoot yourself in the foot or in other words the great pedantic lengths you have to go to in order to not do so.

A language that avoided it would have to be very close to C while making it only mildly more difficult to foot shoot. Everyone who is trying is overshooting and therefore not really writing an adequate replacement low level systems language. Even if they did, it would be so close to C that adoption pickup would be low, awkward, and the language would fail outright. (Think Python 3 but worse)

>But I bet they would criticize programs for being written in assembly, if they didn't need to be.

Certainly. If you're writing your web app in assembly you are very likely a crazy person unless your goal is to do something ridiculous. If you're writing some assembly in a critical path in a web server to precisely control the network stack, you might not be a crazy person (see Netflix tech blogs).
Downvoters please explain what's so stupid about my question.
i actually have access, but nature.com was down at the moment. Sci-hub it is
Lookup "Dunning-Kruger effect"
The standard library doesn't, and most crates don't, but I'm pretty sure nothing prevents you from writing libraries in a style where all IO requires mutable access to some explicit unique "World" object, similar to Clean.

Passing a unique world object around is effectively the same as composing with the IO monad, and borrowing 'f(&mut world)' is basically equivalent to 'let world = f(world)'.

Maybe someone will one day write a standard library in that style.
I dream of a GCC/LLVM for FPGAs. I'm not holding my breath for Intel to help with that though.
That is where the excitement comes from. You think you know C, but when you least expect it something come up that bites you in the backside.

I love C for its warts and all, but you should treat it like a tamed wild animal.
Discussion: https://news.ycombinator.com/item?id=15382274

There are a number of other submissions of this story, but the titles vary wildly and I haven't been able to find any other significant discussion.
There was no relationship between variables is not participation trophy. It is a result and should count as one. As long as science is concerned with finding truth.
With unused mining hardware reserves they could smash outsiders by ramping up the hashrate.

Cartels usually don't last forever, but they can last for a while. In the case of bitcoin, it could reduce total energy consumption.
Amazon delivers food in slots of 1 hour whenever you want.
My bullseye metaphor was maybe a little off; the "target" I was talking about was not economic success, in which case YC hitting it is indisputable. It's the idea that this essay contains the principles necessary to achieve those financial results.

My claim is that YC has many principles that led to its financial success, and not all of them are, or are really compatible with, other principles mentioned in this essay.

("Good" as used in this essay also shares a kind of empty essentialism with Google's "evil" - a focus on BEING good or not BEING evil, rather than the trickier question of how to DO good / avoid DOING evil - https://www.theatlantic.com/technology/archive/2013/10/what-...)
Rust is very sweet, but it lacks the simplicity of C. I get that ML style programming is all the rage today, and ML itself is a simple language, but programming languages today carry a lot of baggage and styles, maybe to cater to wide range of programmers. But in the end, it complicates the language. I have noticed that a lot of people find Rust or Scala to be very hard because of these reasons.
Why not just be more clear and instead of writing the "p-value < 0.05", write: The probability that the difference between these two groups is by chance is less than 5%. Then everybody knows that if you do this a bit more than 20 times this results is achieved by chance alone. Then, just show the damn plots and let me see how much distributions overlap. I have seen insanely small P-values with completely overlapping distributions just because of large amounts of data. I find the P-value near useless.

Personally I much prefer ROC curves, they are much better at showing the difference between distributions. Still, nothing beats the raw data and healthy skepticism.
Body clock scientists win Nobel Prize
Yes, that's why I said what I said.

The mix of the two in my stomach is not a pleasant feeling.
Check out Working Copy, which I use extensively but I'm not sure it's what your looking for exactly (I'm not affiliated). I think there's iOctocat if you're just looking for a way to browse github repos.
> But still I'm failing to see what your point is about the "real bash solution"

It's accepting that bash sucks at strings, and trying to keep it as far away as possible from the data in the pipeline. You keep pointing to the nulls and say, bash is bad at this and oil is good; but it's a strawman since bash doesn't have to even see the nulls for a bash script to be 100% correct at escaping the git log messages.
Pubfront | Backend/DevOps Developers | Copenhagen, Denmark | ONSITE

Pubfront develops and maintains a platform for publishing, selling and reading/listening to ebooks, audiobooks and comics, currently licensed to several large publishing houses in the Nordics. We're now looking for two or more developers who love working in Python and Django as much as we do (we're an active part of Copenhagen's Django community) to join our team.

We're mainly looking to fill two positions:

* Implementation/DevOps Developer: keep our sites running smoothly and help out our clients with custom projects (http://pubfront.com/implementation-devops-developer/)

* Backend Developer: work on the core webservices that are shared between all our clients (http://pubfront.com/backend-developer/)

Apply to: jk@pubfront.com
InterSystems Developers Meetup 25th of October, Cambridge MA, CIC
Due to lack of GC support, C, C++, and Rust are what you can reliably use with wasm at the moment. That integration is coming in the future, and should lead to other languages working well too.
My thoughts exactly - I have literally never seen promotion happen in 15 years employment. I have approximately 0% chance of moving into management naturally within an organisation. Software developers are treated as highly paid secretaries - secretaries do not get promoted no matter how long they serve (which I also think is wrong). To move into management I will need to take lots of courses in my own time and push recruiters to give me a shot and then once I'm in an interview I need to be able to talk like a demon to convince them to give me a shot. There is very little upward mobility for a software engineer in the UK outside of big-name firms.

So I'm going contracting, where I atleast get a little respect and my market value (approx 2x full time employement salary).
Lua is incredibly easy to embed. The whole Lua interpreter including the standard library is about 150kb. That's Kilo, not mega! You can swap out the memory allocator or the number type on one simple header file. Lua was built specifically for embedding!
What is more, it is a joyously well designed language that is well suited for building DSLs. And it is pretty fast and memory efficient for a dynamic language.

Other options are TKL, but the syntax is a bit unorthodox. Or Python, but it is much bigger, and harder to embed. JS is not a great fit, I would say, mostly because it is comparatively HUGE and not particularly optimized for embedding.
Our brains perceive a fraction of reality to keep us alive
He's playing the long con, you see. He founded SpaceX even before getting involved with Tesla for this very reason /s
The ability to compile C code to WASM will be invaluable for porting well-used C libraries to the web, but given that the goal of WASM is to define a ("more-or-less") language-agnostic bytecode, I see little reason why people would prefer to use C when they could continue using Javascript, or, eventually, whatever the 40-years-from-now equivalent of Python is. (Of course, you'll always be able to use C if you do want to, so it's not like it's ever going to risk vanishing.)
This is true of most sound static analysis; the goal is to reject as few programs as possible, but there's always some things that exist in the world that your system can't take into account.
Snapchat’s next AR trick is giant art installations
We spent years iterating on Rust's design; I hope somebody comes along and makes a language that is even easier than Rust is while satisfying its requirements. That's currently an open question though, and we need to write programs today.
It's more that any consumer grade processor seems to have this limitation.

I have an i7-6700HQ for example, and I can either have Hyper-V turned on (I'm on Windows) in which case I can only run 32-bit VM's with VirtualBox, or I can turn off Hyper-V in which case I can run one 64-bit VM on VirtualBox, and then only 32-bit VM's past that.

If I'm doing Android development, I can't run a 64-bit VM at the same time as the Android emulator is 64-bit.

Sometimes I want to run my web server, an Android VM, and maybe a Redis server on Ubuntu in a VM. I can't emulate Android and run a 64-bit VM, so the 32-bit Ubuntu distro is invaluable here.
No, couchDb is older than DynamoDB, and according to wikipedia there's been nosql databases since the 60s
As maddening as it may be, my gut tells me it has more to do with the precompiler than anything else. When it comes to wrestling with cross-platform differences, I don't know of a corresponding feature in Rust or Go that is equally powerful (or equally ugly!).

As long as computing remains a battleground where rich assholes put vastly different wrappers around the exact same shit so they can wring more money out of us, I will probably be writing in that abominable assembly language w/ turing-complete string-paster for many years to come.
It is in "English" (UK) English - the author of the parent comment may not necessarily be American.
Are there any apache projects that do this?
The wasm project states that obsoleting JavaScript is a non-goal.
I'm working for a healthcare insurer and I don't believe anything has been rewritten since they went from mainframe to .Net.

The previous application I worked on is over a decade old (and it shows). The current application I'm working on is about 8 years old.

Neither applications has any sign of being replaced. Which would be insane, as they both have roughly a decade of laws & regulations and business lessons embedded in them. Despite the state of especially the older application, I don't see how rewriting the entire application would fix anything.

At best parts would be rewritten. And the parts I'm thinking about wouldn't be rewritten because of technical reasons, but because of the way they work. The prime example is a part that only 1 person, a business user, understands.
How possible do you think it is to create a new language which is almost, but not quite, exactly the same as C?

Edge cases that have evolved into it do have plenty of problems, but it's very difficult to create a new backwards-incompatible standard which is just a little bit different.

Then again, the embedded (microcontrollers) world seems to be filled with slightly esoteric implementations of C and everybody gets along just fine.
IoT buttons by numbers
"If they get fired or the startup goes under, now they face a very real situation where they might not be able to feed or house their family." this is true for all jobs, my point is, unless you are working for free, you arent giving up something that you will lose. Time yes, but thats why you need to make sure you get paid what you think your time is worth.
Mostly for my own edification/enjoyment. It's something I've wanted to do for a long time, and once you have that itch, it's just a matter of time. I've built some toy compilers before, but this project I'm aiming a lot higher to see if I can combine some recent research in type theory (algebraic subtyping as an extension of ML-style type inference, effects) and the bits of languages that I would really love to see meshed together (rich pattern matching, including pattern matching on binary data, macros, zero/low-cost abstractions, Erlang-style concurrency with actors/supervision/transparent distribution) and see if I can still find a sweet spot where the language is still approachable, has good tooling, etc. I've accumulated a lot of research and notes, but only recently started working on an actual implementation. At this point nothing is set in stone, since I'm not certain all of those things are actually compatible in a single language, but those are the goals I have in mind for now, so we'll see where it takes me.

As for why I chose Go, I wanted something which was pretty portable, with decent performance, easy to build command line tooling in, but at a slightly higher level of abstraction than C; that way I could conceivably port it to C or C++ relatively easily if I felt like that was a better way to go down the road, but could mostly focus on getting things done in the short term. I'm not a huge fan of the OCaml toolchain, even though I like the language, and it's not very approachable for other people if they wanted to pitch in. Go isn't an ideal language to build a compiler in, but it's not bad either. I'm comfortable with it though, and that's all that really matters for a project like this.