steinuil

I can understand that, I just disagree that to be a better employee one should also devote their free time to an activity that directly influences one's performance review at work. This is definitely a good deal for people who enjoy doing OSS work on their own time-- but it feels wrong and not fair to those who don't want or don't have time to put the extra hours for that.

I've seen a few trying to apply to my company. They had a few projects in the languages they had on their resume, but upon closer inspection you could see they were just project templates they had gotten from some tutorial, made one or two insubstantial changes to and then uploaded to github.

Does your company allow engineers to work on OSS while they're not busy? If not then how can you claim you're proud of their contributions, and don't you feel like you're coercing people into working overtime to get a better raise or a promotion?

I don't understand what's the difference between single-parameter contracts and interfaces. Aren't contracts only useful when there's two or more type parameters involved?

Edit: didn't read through the whole thing, I guess contracts can do things that interfaces don't. I think the overlap still makes things a bit awkward though.

This is more of an issue with JS than React. ReasonML also has JSX support and since `if` is an expression rather than a statement you can do this:

    <div>
      {if (cond) {
        <Comp1 />
      } else {
        <Comp2 />
      }}
    </div>

Or even:

    <div>
      {switch (expr) {
      | A => <CompA />
      | B => <CompB />
      | _ => <CompC />
      }}
    </div>

OCaml does just that; it might have been the first language to have 0b and 0o prefixes for binary and octal literals.

https://discuss.ocaml.org/t/the-origin-of-the-0b-01-notation...

I hope they're going to release it later, after cleaning it up. Quake 2 is GPL'd, so I think they're compelled to, and it would also be a good example of how to use the VKRay API and what it looks like in an actual game.

Other than the games they wrote entirely in GOAL, all of their PS3+ games use a series of lispy DSLs implemented in Racket that get compiled to C and C++ for defining data to be loaded in the game and dependencies between these data, light scripting, dialogues, stuff like that.

There's a talk by one of the engine devs at RacketCon from a few years ago on youtube about how they use these DSLs and how they came to be: https://youtube.com/watch?v=oSmqbnhHp1c

Encoding and decoding of JSON usually adds huge amounts of boilerplate (in some small-to-medium-sized apps it might account for more than half of the LoC), and separating an app into modules requires you to add some boilerplate in your update functions.

On a purely syntactical level, F# has a "light" indentation-based syntax mode which can be toggled on a per-file basis, and OCaml recently got a whole syntax revision with curly braces in the form of ReasonML, which the build system automatically recognizes based on its file extension.

Neither of these adds new keywords (ReasonML switches some around, e.g. match is now switch) but maybe one of these approaches might work for language features or breaking syntax changes or revisions.

OCaml is not Haskell, but it does provide almost all of the guarantees Haskell does. Here's a list of popular software you might have used written in OCaml:

- the Flow and Hack compilers

- Facebook's Messenger app

- Jane Street's entire trading infrastructure (and everything else they do)

- XenServer

- some parts of Docker, including the TCP/IP networking stack on OS X and Windows

Thanks, I'll definitely be looking forward to any improvements on that!

Has the input latency improved any? I liked alacritty, but I switched to mlterm after a while because the input latency was really bugging me.

That's very possible to prove in non-english-speaking countries, where surges of foreign names (along with some very creative misspellings) usually coincided with the first run of a foreign TV drama that had a character named like that, shifted by a few years.

In the region I was born in it was customary to name your firstborn after your father or your mother, and then your second child of the same sex after one of your parents' siblings, if none applied you'd turn to uncles/aunts, and so on.

Open sourcing their projects is good from a PR standpoint in this climate, and if anything it's a good way to share knowledge that would otherwise be kept within the company walls with those who need it (e.g. implementors of PHP/other VMs).

Creating and maintaining a community around an open source project is a lot of work, and it's understandable if Facebook doesn't want to pour many resources into this particular project, even if they keep it open source.

So this would just be another form of the "Lisp curse"?

http://winestockwebdesign.com/Essays/Lisp_Curse.html

That's definitely not a tail call, and even with a smart compiler it's pretty hard that it would get optimized into "return f(a)".

If "x" is declared there and never mutated in the subsequent code, and the code in the "..." doesn't perform any side effects, then such an optimization could occur... but then again, if the code in the "..." in your example didn't perform any side effects, it'd be dead code.

Tail calls do not just deal with recursive functions, in general TCO works on any function call in tail position. Maybe a more general recur construct (maybe called "jump") would be a good idea, but then you'd have to remember to use it.

Probably not what you're searching for, but youtube is full of recordings of tech talks and I watch them all the time. If I want to hear about a particular topic I'll just search for the topic or "<topic> talk", but I also have a few channels related to conferences and things like that bookmarked. They're only useful once a year, but it saves me from searching randomly when I don't have anything particular in mind: GOTO Conferences, Jane Street (they recently started uploading videos of talks they host at the company), Strange Loop, Curry On!, PapersWeLove, CppCon, InfoQ, Racket Lang, ICFP.

Other than that:

Super Bunnyhop (videogames, very interesting investigative journalism every now and then) https://www.youtube.com/user/bunnyhopshow

Leonardo Da Sidci (videogames, amazing production quality and very introspective topics) https://www.youtube.com/channel/UCujjLOPLW92zVBlhaL8wxPg

Archipel (short documentaries focused on japanese creators and artsy videos) https://www.youtube.com/channel/UC3zoY9LapZERsN7caDKqz0w

Noclip (long form documentaries about videogames, mostly made up by interviews directly with the developers) https://www.youtube.com/channel/UC0fDG3byEcMtbOqPMymDNbw

byoblu (italian "videoblog" about politics featuring lots of interviews and discussions, always to be taken with a grain of salt) https://www.youtube.com/user/byoblu

Then, a lot of comedy channels of dubious value which I'd rather not embarrass myself with on here.

Every once in a while some random account forks one of my repos, and when I look at the account to see if they do anything interesting I see dozens of empty forks, many of which seem to be created within a timespan of a few hours or so.

My guess is that some people use them as bookmarks... but isn't that what stars are for?

I don't think having a glass of wine at lunch or dinner can damage your health; in fact I recall reading somewhere that it's actually healthy. The problems start when you go over that.

I know, but using it is not exactly legal and having to rewrite it all from scratch would be bothersome, even using the original code as reference. There's a set of C++ macros used for "scripting" the AI and the missions which I would immediately tear out if I had to rewrite the engine, and I'm afraid replacing it with something more sane while still retaining compatibility with all the fan missions and so on would take a lot of time. Plus, as you said, not all the code was in the leak (though I don't know exactly how much is missing).

The community hasn't really warmed up to The Dark Mod as I thought it would. I guess everyone's more comfortable with how the original games look and feel, and I can't say I don't understand it. Thief still plays great thanks to its minimal controls and UI (much unlike System Shock 1, which feels horribly outdated) and looks nice thanks to its amazing art direction (just look at some of the screenshots in here https://twitter.com/thiefbsp), so I don't think people would feel the need to move on to a clone unless it was that much better.

Nice! I can only hope the same will be done for Thief 1 and 2 (and SS2) someday.

The Thief games still have a very active community that regularly produces high quality fan missions, and one of the original engine developers has started releasing unofficial patches to make the games run on modern systems a few years ago. I'd love to read the games' full source code and to be able to play them on Linux without bothering with Wine

It also fails to mention virtual youtubers, who are "virtual" youtube personalities with a 3D model as body and whose videos take place entirely inside 3D environments.

Obviously they're being played by real actors with motion control equipment, but there's a lot of work that goes into making them feel believable as virtual characters, with facial expressions and lots of other animations that are probably added after recording.

They've become very popular in Japan over the last year. The most famous one is called Kizuna Ai: https://www.youtube.com/watch?v=NasyGUeNMTs

It uses formal methods to verify that the generated machine code has the same behavior as the source program.

I think Evan is too protective of the language to let anybody else maintain it right now, the first step would be for him to realize that he should give it up just a bit.

Letting a program arbitrarily modify another program's working directory or its environment variables would be a nightmare for any program that accesses files from relative paths, I think it's pretty obvious why you wouldn't be allowed to do something like that.

I'm really not sure what you mean by "modularity". There's a lot of languages with much more readable and composable type declarations than C. For example in OCaml:

  let x : (int list ref, string) result option =
    let x1 : int = 0 in
    let x2 : int list = [ x1 ] in
    let x3 : int list ref = ref x2 in
    let x4 : (int list ref, string) result = Ok x3 in
    Some x4

The declaration of List.map:

  val map : ('a -> 'b) -> 'a list -> 'b list