shadowfox

Off topic. Got to say that you have got quite an interesting system there.

Not quite sure what is new here. The MSVC compiler has been available for free for close to a decade at least and command line compilation was available ever since I first used it (in the mid 90s)

For an experience similar to locate on Windows + NTFS systems, there is Everything [1]. It also has a command line tool that you can use (well) from the command line.

[1] http://www.voidtools.com/

> Self referential consistency makes sure I do not make errors within the logical model I have set for myself. It does not help me build better models but once those models are built it helps me to compose programs that do not break the invariants in the chosen formalism.

I think this is a valid point.

But I am less convinced about the second part. I feel that better type systems do help one model the world better (while retaining the consistency checking that you mentioned). In my mind at least having more/better "type tools" is like having differently shaped pieces in your lego tool box. You can create better models for yourself, because the pieces allow you to. And the more experience you have with them, your modeling abilities also improve.

> I don't really see what is evil about Monsanto? They're just a regular technology company. We, better than anyone, should understand technology companies.

Not the OP. "Evil" is a value judgement that many may not agree with.

But imho Monsanto is a little bit more than "just a regular technological company" as you put it. This section on Wiki makes an interesting read for example: https://en.wikipedia.org/wiki/Monsanto#Legal_actions_and_con...

> But if zeroing memory is necessary for the program to be correct, hang the cost.

Sure. And your application should bear that cost and not necessarily every application written in C. Maybe there is a case for using a safer malloc implementation for your program?

> I don't know what sort of "real time applications" would require gambling on the initial state of memory.

This isn't really gambling. If you know you are going to initialize the memory with sane values immediately (and this is a common practice), it is a waste to do that initial zeroing.

> I wouldn't dream of keeping a blog that couldn't handle a HN traffic spike. That's the whole point of having a blog.

It seems possible that some people don't care that much about HN traffic spikes.

> but the program which gets deeper in the movement tree, should always win

It doesn't always work like that. Usually, since examining, the whole move tree is very expensive, heuristics tend to kick in at various points providing assessments for positions (thus helping to prune the tree). It is quite possible to land in a position where your set of heuristics is not quite right.

Or WX widgets.

> IMO, the only defense against doxing is to dox yourself. Doxing is just a form of intimidation, after all, usually done by people who think publicizing some "secret information" will be taken as a vague threat. Make the information public and you remove their ammunition.

> To me, the best defense against a troll is being completely nonchalant and not giving a shit what they do. Hacked my accounts? Oh well, it's just an account, i'll make another. Sent me death threats? Hey, life is short and we all die some time.

I am clearly a little less nonchalant than you. But I don't feel all that inclined to publicly post my home address or my kid's school address or scout camp location.

> In reality, any code beyond trivial complexity will benefit much more greatly from algebraic rectification, which can only be done with certain languages that are amenable to formal analysis

What exactly is "algebraic rectification"?

While it is generally true that having a formal semantics aids greatly in analysis, it is worth noting that a very large amount of program analysis work is targetted towards C. (And mind you, flexible, high level languages bring with it their own troubles. Analysis in the presence of higher order functions is not a panacea at all)

He may be talking about interfacing with C code of that nature. (You can still localize most of your new/deletes in to the wrapper classes though)

Side note on Windows distributions: Besides ocpwin-distrib there is also Wodi [1] which started as a port of Godi and is fairly stable on windows.

[1] http://wodi.forge.ocamlcore.org/

> Why is this at the top? It's obvious flame bait.

And then you took the bait!

There is always idea of Gradual Typing [1] which has been implemented with varying degrees of success. There are also a large set of static analysis theories/tools which can help here.

It is also worth noting that if you dont want (global) type inference, you can get far in a language with permissive casting, type annotations and local inference. The results aren't a panacea though.

> Suppose you could catch 99% of type-based errors instead of 100%, and in addition, use a compiler switch to see all the case statements where a class of a type is missing.

I am not quite sure what you mean by this. Care to elaborate? (In general, with inference systems, missing type information is hard(ish) to localize. So pointing out where exactly a type error occurred is non-trivial)

[1] https://en.wikipedia.org/wiki/Gradual_typing

> It's an unpopular opinion, but I don't think that everyone should have a roughly equal say in how things go. The average person isn't as well equipped to deal with large problems as the elite are

The usual trouble with this sort of idea is who gets to decide the "elite" that makes the decisions. How do you prevent this group from becoming an insular clique and debar other people from similar opportunities etc.

Power, imho, has a tendency to be self-propogating; people who achieve it hold on to it far after it is useful and tend to bestow it on their proteges, irrespective of their suitability to the task etc. (Anyway it is an opinion; you may disagree)

From Acme Faq [1]: "No. The creator of main users of Acme find syntax highlighting unhelpful and distracting."

[1] http://acme.cat-v.org/faq

Somehow I have never found that essay very convincing.

There is something to be said for clean language design and minimal, a non-distracting editing environment, of course. But the essay doesn't argue the case in any reasoned fashion. It mostly just makes emotional arguments (the talk about training wheels, the example with highlighting fiction, which is over the top).

I have worked with large codebases in plain vi and PFE [1] in my wayward youth. It wasn't exactly what I would call a pleasant experience.

[1] https://en.wikipedia.org/wiki/Programmer%27s_File_Editor

Not defending the particular point of view above.

But to me it looks like a lot of personal experience is just personal; it is subjective and it is hard to establish a particular experience as "fact" without widespread consensus. So faith might be necessary in the meantime.

I don't disagree with you per se. But I think you may be overstating the case.

Once you are a C++ programmer for a while, you start to discern "standard" patterns for this sort of thing and tend to automatically use them. (The patterns might depend on the C++ version and to an extent the code base in question; but it is common to have such helper function take a const ref as input, return non-primitive return values via a out-parameter etc).

So while C++ might "encourage long functions", I think that may be the case only for newbies to the language. Once you have a some experience working with it, you no longer need to put that much thought in to every little decision.

Many license management software are especially bothered by time changes of this sort.

>> While most OCaml implementations have poor standard libraries

> That right there should tell you something.

I wouldn't use that as the main criteria to judge a language. C has a poor standard library (for a definition of "poor" relative to, say, python) and so does C++. But they are certainly useful tools in their domains.

In any case, OCaml has a couple of standard library replacements/augmentations that reduce the gap a bit. (Batteries Included [1] and Jane Street's Core [2])

[1] https://github.com/ocaml-batteries-team/batteries-included/

[2] https://github.com/janestreet/core and https://github.com/janestreet/core_kernel

> Probably the biggest problem on Windows is that OPAM, the package manager, doesn't work there. That will come eventually, though

Wodi [1] is a reasonable choice until OPAM starts supporting Windows. It includes many of the interesting/useful libraries (including, importantly, batteries [2] and core [3])

[1] http://wodi.forge.ocamlcore.org/ [2] http://batteries.forge.ocamlcore.org/ [3] https://github.com/janestreet/core_kernel

It also helps that Gandhi was highly educated (for his time), was a lawyer and quite a good writer, orator and politician. Not exactly the characteristic of an unsmart person.

Just want to add that there are other shorthands which are pretty solid (and more easily available). For example, Pitmans: http://www.long-live-pitmans-shorthand.org.uk/

> it’s essentially impossible to get recaptcha to return a false result.

Famous last words :P

There are, in fact, some initiatives to try to get more men in to nursing for various reasons. For example, see this (http://www.minoritynurse.com/article/men-nursing). The article has a few references at the bottom which also make for interesting reading.

Of course we come across more articles about women in tech because we frequent tech forums. But the topic (of men in nursing, teaching etc) do come up on the relevant forums.

You still can audit the code for security purposes pretty easily using the tarballs if you were so inclined. While granular commits (of the sort you see with public repos) are useful, they are by no means necessary for this sort of thing.

> if you want your project to truly treat Windows as first class, you have to recruit people who know, love, and use Windows.

HN rumor has it that these creatures are mythical ;)

This sort of distinction exists in other languages though: Java has == and equals. OCaml has = and == etc. (Not that Perl doesn't have its issues; but this is very low in that list imho)