Wingolog

My favorites are: http://wingolog.org/ https://www.journal.stuffwithstuff.com/ > I miss the 2009 era of blogging about personal projects I've been doing that. Not sure if I've made it into anyone's favorites yet. https://www.matheusmoreira.com/

For a long time -- until Andy Wingo took over development -- Guile was kind of a joke of a Scheme. It was horrendously slow and buggy, and it was updated very infrequently. Since Andy took over, it's quickly become one of the better choices for Scheme. Guile 2.0 is solid and reasonably fast. The 2.2 release is shaping up to be even better and even faster. Andy has done a great job with it, and he keeps his blog[0] updated with a lot of interesting posts about Guile internals and development. [0]: http://wingolog.org/

Yes, functional side of things is interesting and rarely covered in the standard compilers courses. There is an old but good book, often overlooked: "Functional Programming" by Anthony J. Field and Peter G. Harrison (1988). Despite the title, it's more about various compilation techniques. Also an old but still relevant (it is missing the STG, but otherwise full of interesting stuff): http://research.microsoft.com/en-us/um/people/simonpj/papers/slpj-book… It also worth following this blog: https://wingolog.org/

The best blogs don't have daily content. In fact, the best blogs usually post once a month, or less - often much less. Here are some: http://prog21.dadgum.com http://www.moserware.com http://ridiculousfish.com/blog http://wingolog.org/

Guile is a great little Scheme. I found it to be a very welcoming environment to program on Linux and I'm having a ton of fun relearning Lisp with it. Having tried using SBCL as a "Unix-ing with Lisp", Guile was so much easier. It Just Worked the way I expected when touching the OS, compared to CL's crazy filepaths and time epoch. I've also greatly enjoyed reading the compiler/VM backstory on http://wingolog.org/ . It occurs to me that if you have an efficient Scheme VM, you could use it as a target for a lot of other languages and get something of an 100% OSS .Net or Java polyglot ecosystem going. Parrot was the previous hope but it seems to have fallen into being a mostly academic exercise. And then there's "GuileMacs", which seems to get closer to a reality with every push. Not being a native Lisper, I think Emacs could use a boost from having a faster VM and lexical scope. Really there's just a lot to love about Guile. I'm excited about all the activity and attention it's getting.

Fun read! If anyone is interested in more, I believe Andy Wingo has written about the implementation of delimited continuations in guile scheme over at https://wingolog.org

My favorite trick: NaN boxing. NaN's aren't just for errors, but also for smuggling other data inside. For a double, you have whopping 53 bits of payload, enough to cram in a pointer and maybe a type tag, and many javascript engines do (since JS numbers are double's after all) https://wingolog.org/archives/2011/05/18/value-representation-in-javas… https://piotrduperas.com/posts/nan-boxing

If you want to read just an enormous amount of well-written bloggage about optimizing Guile Scheme, this is the spot: https://wingolog.org Andy Wingo is the maintainer and I get a kick out of everything he posts.

They're pretty close to the same thing. A good read on this is https://wingolog.org/archives/2015/07/27/cps-soup. Consider block arguments instead of phi nodes. That makes the correspondence between a function and a basic block especially clear.

Followup: https://wingolog.org/archives/2023/11/14/whiffle-a-purpose-built-schem…

> If you are hell-bent on using FixedBufferAllocator only and you want to avoid copies, there is a way. Using two buffers (and separate allocators backed by them), it is possible to keep swapping between them after every iteration. I found this bit lovely: the author has independently reinvented the core idea of semispace copying garbage collectors (see eg https://wingolog.org/archives/2022/12/10/a-simple-semi-space-collector…

https://wingolog.org : lispy/ecmascripty/WASMy implementation details

I often find that DRY is in conflict with Conway's law[1]. It's almost always better to let Conway's law win. If I help write a build script for one team, I often copy and paste it into another's git repo to instead of trying to share it. It's often way better than factoring it poorly[2] or getting the two teams to coordinate on changes they need to make to it. Best to let the two copies diverge in that case. 1: https://www.wingolog.org/archives/2015/11/09/embracing-conways-law 2: https://sandimetz.com/blog/2016/1/20/the-wrong-abstraction

> I think that future compiler and VM writers and FPGA soft-CPU authors -- should target this "abstracted instruction set"! GNU lightning succeeds in what it sets out to do, which is to offer a simple and minimal JIT code-generator. It offers nothing in the way of optimisation, by design. Most projects looking for a code-generator are looking for something with great optimisation built-in, so they're not wrong to go with LLVM or the JVM rather than GNU lightning (or something similar like Mir [0][1]). I don't think the average compiler would gain much by targeting GNU lightning. With all that said, GNU Guile, a Scheme interpreter, uses a fork of GNU lightning, insufferably named lightening. [3] [0] https://github.com/vnmakarov/mir [1] https://lists.gnu.org/archive/html/lightning/2020-02/msg00014.html [2] https://wingolog.org/archives/2019/05/24/lightening-run-time-code-gene…

> I had to google what guile was I'll certainly be trying to avoid it now. By avoiding Guile or Wingo's otherwise instructive technical notes (see, e.g., https://wingolog.org/archives/2017/06/27/growing-fibers), aren't you likewise conflating character with merit? I've never used Guile (I'm invested in Lua), but I like to follow the development. It's an interesting and high-quality project.

https://wingolog.org/archives/2013/01/07/an-opinionated-guide-to-schem… A bit old now, and Schemes only, but still worth a quick look.

This release has been a long time coming and I'm happy that the day has finally arrived. There's a small patch of mine in this release (my first compiler hack ever) that optimizes comparison operations for floating point numbers. If anyone is interested in hacking on compilers, I highly recommend checking out Guile as one of the easier points of entry into the space. Andy Wingo, the author, even wrote up a blog post with plenty of project ideas to improve things: http://wingolog.org/archives/2016/02/04/guile-compiler-tasks

The man, the myth, the legend Steve Yegge's blog(s) are worth reading if you haven't yet: https://sites.google.com/site/steveyegge2/blog-rants http://steve-yegge.blogspot.com/ Armin Ronacher's blog is also excellent: http://lucumr.pocoo.org For the Schemer, or the compiler hacker, Andy Wingo's blog is fantastic http://wingolog.org For insights into debugging, kernels, and debugging kernels, Bredan Gregg's blog is fantastic. http://www.brendangregg.com/blog/index.html Finally, I wish to list a non-blog: and unblog, or perhaps the remnants of a blog once passed. This is an archive of John Carmack's .plan between 1996, and about 2005. https://github.com/ESWAT/john-carmack-plan-archive It is still a fascinating read.

Speaking of SSA and optimizations, I just remembered that Andy Wingo (core contributor to Guile scheme) has a treasure trove of great articles, e.g. a fun intro to SSA [1] or CPS as used in Guile [2]. His blog is totally worth just browsing around. [1] http://wingolog.org/archives/2011/07/12/static-single-assignment-for-f… [2] http://wingolog.org/archives/2014/01/12/a-continuation-passing-style-i…

Your knowledge of Guile is outdated. Read http://wingolog.org

I always felt Slava Pestov's (now abandoned) blog on Factor's development was a good view into language design: http://factor-language.blogspot.com/ He and Andy Wingo (http://wingolog.org) both write very well on language issues though they may skew towards implementation concerns over design concerns.

I recommend Andrew Kennedy's "Compiling with Continuations, Continued" article if you are actually interested in using continuations in a production compiler. Might's formulation of CPS is good for analysis but not actually that great for code generation in my opinion. My take on the topic is here: http://wingolog.org/archives/2014/01/12/a-continuation-passing-style-i…

To be fair - I've never seen such docs for SpiderMonkey. I may have just failed at finding them though. Keeping up-to date documentation of compiler is a horrible job. I think it's good enough that V8 may be built as standalone binary with really extraordinary debug options and tools. At the same time, I'd love to see more talks like http://www.youtube.com/watch?v=FrufJFBSoQY There are also guys who write about V8 from time to time (http://mrale.ph/ http://floitsch.blogspot.com/ http://wingolog.org/tags/v8) but this is needle-in-a-haystack type of learning.

This reminded me of Andy Wingo (http://wingolog.org), a Guile hacker who works with/for Underkoffler (Oblong).

If you look at guile's history up to 2007 or so, it might indeed look like a failure. But since then, development has been taken up again, and progress is amazing. Andy Wingo did a lot of the work and has been blogging about it at wingolog.org, see especially his talk about the recent developments: http://wingolog.org/archives/2010/04/02/recent-developments-in-guile. Guile now has significantly improved performance, a compiler, and it can run JavaScript and Emacs Lisp besides Scheme. The 2.0 release is around the corner. Things look good.

I'm a DevOps engineer. I totally buy duplication is better than the wrong abstraction but I'd like to nuance it: duplication is better than an abstraction used by two disparate parties (groups of people that don't talk to each other). This is in agreement with Conway's law, which absolutely governs everything I do. I work on a DevOps team that supports several different development teams all working on different things. The code I write for those teams I often duplicate along team boundary lines. Build scripts, for example, I write and I put them in each team's git repository. These might look very similar. This allows the scripts to grow and change and evolve according to the different teams needs without the teams needing to talk to each other. "Proper duplication" goes back to separation of concern. If you have two different concerns (using the lens of Conway's law, two very different teams) using the same code, perhaps they should not be using the same code because that is not a separation of concern. Separate the concerns by separating the code paths both concerns use. This type of duplication is praised in more depth on wingolog[1]. I highly recommend reading it as something every engineer should read. It's very important to know when to duplicate and when not to do so, because duplicating it the wrong time can lead to pain, but not duplicating can lead to pain also. 1: https://wingolog.org/archives/2015/11/09/embracing-conways-law

If by "feminists" you mean GNU maintainers and other free software hackers (who may well be feminists, but this is a sharp subset of feminists in society as a whole), then correct, his personal political views are not by themselves the reason they want him out. It's the fact that he is so committed to the advocacy of his personal views that he is harming the free software movement. See, for instance, this post from the author of this email (and linked in this email): https://wingolog.org/archives/2019/10/08/thoughts-on-rms-and-gnu > The great tragedy of RMS's tenure in the supposedly universalist FSF and GNU projects is that he behaves in a way that is particularly alienating to women. It doesn't take a genius to conclude that if you're personally driving away potential collaborators, that's a bad thing for the organization, and actively harmful to the organization's goals: software freedom is a cause that is explicitly for everyone. and this, from a former member of the FSF Board of Directors who resigned so he could speak up: http://ebb.org/bkuhn/blog/2019/10/15/fsf-rms.html > More importantly to the FSF, I attempted to persuade RMS that launching a controversial campaign on sexual behavior and morality was counter to his and FSF's mission to advance software freedom [....] After years of conversing with RMS about how his non-software-freedom views were a distraction, an indulgence, and downright problematic, his general response was to make even more public comments of…

Hi Eric! W.r.t. the co-op, at the moment my ideas (or fantasies) are more about organizational stuff than the content (what we would work on). I am just gathering ideas, learning and keeping my eyes open waiting for all this to crystalize... My motivation is to be able to work with other people in a democratic and (internally) non-capitalistic way. You are still playing in the market so there are lots of contradictions that you would have to assume, but I think there is a lot of progress one can make nontheless. For me Igalia, as I mentioned, is a source of inspiration because they have been going for quite a while and they are about ~50 people now and have a good business. They are also very democratic and flat (e.g. everyone has equal pay, something shocking but with very good rationale). They also do excellent technical work---for example, they have been the ones implementing a lot of ES6 features inside V8 and SpiderMonkey. If you want to read about them, Andy Wingo (the person I know from there) has 3-post series on the topic here: http://wingolog.org/archives/2013/06/05/no-master On a more political side, recently I read the Telekommunisten manifesto which also touches on cooperative models as a way to do social change for real: http://telekommunisten.net/the-telekommunist-manifesto/ In my student times I was very much into activism, but since I started working I stopped "having time" for it. I was also burned out from the energy and emotional sink that…

Dan Luu has a list of programming blogs you might like: https://danluu.com/programming-blogs/. The rest of his blog is good too! a few of my favorite blogs: - http://blog.acolyer.org for fantastic daily summaries of CS papers. - http://stephaniehurlburt.com/blog/ -- she has a business creating a new compression algorithm and I love reading about it - https://rachelbythebay.com/w/ is pure gold for weird debugging stories - https://accidentallyquadratic.tumblr.com/ is always a fun read - http://wingolog.org/ on building compilers - http://composition.al/blog -- Lindsey Kuper on her programming languages research - aphyr's blog on distributed systems, of course - https://charity.wtf/ - http://www.pgbovine.net/writings.htm -- Philip Guo is a CS professor whose blog on his experiences in academia I really like - http://whilefalse.blogspot.com by Camille Fournier, mostly on engineering management - http://larahogan.me/blog/ by Lara Hogan, on engineering management Also I think this comment from Dan's blog (https://danluu.com/about/) is very true and important: > I view that as a sign there’s a desperate shortage of understandable explanation of technical topics. There’s nothing here that most of my co-workers don’t know (with the exception of maybe three or four posts where I propose novel ideas). It’s just that they don’t blog and I do. I’m not going to try to convince you to start writing a blog, since that has to be something you want to do, but I will point out…

Here are some software engineering blogs from my RSS reader in addition to the ones listed in TFA. I honestly don't know how over or underrated they are, but I guess that varies depending on which communities you're closer to. Mikola Lysenko https://0fps.net Graphics programming, geometry and algorithms. --- Steven Wittens http://acko.net Not underrated in any sense of the word, but I have to include it in case there are people who haven't seen it yet. It's about math and graphics, but also about art and design. Amazingly educational. http://acko.net/blog/how-to-fold-a-julia-fractal/ is a good starting point for new readers. --- Mark Nottingham https://www.mnot.net/blog/ Networking and HTTP. --- Jeff Preshing http://preshing.com Efficient concurrent data structures. --- Bruce Dawson https://randomascii.wordpress.com Software efficiency, performance optimization, fractals and more. --- Yann Collet http://fastcompression.blogspot.com Modern compression algorithms. --- Gil Tene http://stuff-gil-says.blogspot.com Also definitely not underrated, at least not in the Java world. But any engineer who cares about latency and honest benchmarks will benefit. Low latency techniques, GC performance, lock-free programming. --- Tony Finch http://fanf.livejournal.com C and UNIX programming, and more. --- Andy Wingo https://wingolog.org Scheme, Compilers, JavaScript, and much more. --- Aleksey Shipilёv http://shipilev.net JDK internals, low-level optimization.