Jari Komppa

I've written a blog post about some (C/C++) libraries I found working well in asm.js/wasm: http://floooh.github.io/2016/04/09/oryol-3rd-party-code.html All the C libraries in there should be trivial to integrate with Rust, the C++ libs might be a bit more complicated though. For audio, I can recommend SoLoud, it's multiplatform and also works well in asm.js/wasm (and doesn't add much size): http://sol.gfxile.net/soloud/

I really love reading recounts like this. Seeing other developers try, fail, and try again to come up with creative solutions for difficult problems, and then finally arriving at a solution, is so satisfying. It really demonstrates how creativity is manifested in programming, and is truly inspiring. A favourite of mine is Jari Komppa's article on his process of porting Death Rally from DOS to Windows: http://sol.gfxile.net/dr_gdm.html. Does anyone have any other articles along the same lines? I'd love to read them!

Cool article, it left out my favorite function though: http://en.wikipedia.org/wiki/Smoothstep This is the magic sauce you need. (more visual demo here: http://sol.gfxile.net/interpolation/index.html)

You can do something similar now using SDL. In fact, unless you are blitting bitmaps or using additional libraries, it is the only way to get stuff on screen. SDL gives you a pointer that corresponds to the video memory and you stick colors into it. Here is a tutorial for using SDL for 'old school' graphics programming: http://sol.gfxile.net/gp/ Of course this would require the student to install SDL and write a makefile to link it all together. I feel that is something worth covering though, since most books just do a bunch of hand waving when it comes to linking external libraries.

> OpenGL is an outdated design for modern GPUs. Its featureset and architecture is too high level, leading to more buggy drivers and complicated legacy support. This is only a problem for game developers who live right on the GPU hardware and need to squeeze absolutely all the performance out of it. Which is probably a small number of admittedly very important developers: Game engines and AAA studios. For the rest of developers who have more modest requirements, I don't really understand what "modern" graphics APIs provide, besides tons of extra boilerplate code and headaches. When I was a graphics programming newbie, it was great to have the whole fixed function pipeline all set up and ready for me to experiment and learn. If I had to learn from nothing on Vulkan, I'd probably have given up before the first 1000 lines. Drawing a triangle in OpenGL vs. Vulkan: http://sol.gfxile.net/temp/hellotriangle.png It's so strange--in most of the software world, newer APIs and tools tend to be higher and higher level abstractions. "Modern" Electron apps run Javascript, HTML and CSS on an embedded browser which itself running on a high-level native toolkit which is probably written in C or C++, which compiles to assembly, etc. You can have a web server in one line of python. In contrast, the more modern graphics APIs get, the lower-level and more verbose they get.

>continue to do great work and we will reach out to you. That's a bit of a sticky problem. It's a hard job finding worthy projects that than benefit the most from funding. There are a lot of projects out there. Some have a lot of potential but identifying them isn't easy. I can understand why there isn't a sign saying "I'm giving away money, apply here." That is a recipe to be inundated with requests where the the most worthy lose out to those more skilled at applying for grants. I wonder if there is scope for a crowd sourced intermediary here. We all think about the worthy causes we could support if we were mega rich. Maybe what we need is a "If I had a Billion Dollars" website where people suggest and critique causes to enable those who do have the money can look to see where they can do the most good. Specifically for Open Source, I have found quiet little projects that could benefit from grants, projects that would never actually seek out funding in their own right. Another aspect are projects that are not yet open source that could possibly be liberated with a fair payment. I see things like http://en.wikipedia.org/wiki/Pixel_Studio_Pro which I doubt will ever be finished as a proprietary project, but might have a chance as open source. Similarly http://sol.gfxile.net/atanua/ is an excellent program that is largely lying idle. Both of these could be possibly bought into the open source world if their respective developers were offered some compensation…

This looks like a neat piece of software to put on the web. It is, however, lacking usability. As a student learning digital design, you want circuit diagrams to be clear and results to be easily and quickly visible. Wires between nodes are laid out automatically and can not be routed on a grid. In a big design (not that this is meant for that) things will get messy quickly. You have to click simulate to see the results of your circuit. This is annoying. These circuits are simple and the output can easily be detected whenever a change is made. Another useful feature is the have keys (0-9) mapped to switches. Testing, for instance, a four bit multiplier would be much easier if you don't have to operate the mouse so much. I hate to recommend another piece of software, but I think the authors can learn a lot from it's features. Atanua (http://sol.gfxile.net/atanua/) is a cross-platform logic simulator that has all of the above features. It was a great tool when I needed to quickly prototype something for a class, and I still recommend it to students in a class I TA. It hasn't been updated in a while, the OSX version has to be run through Rosetta, but I can't see any glaring omissions the author made that would make it unusable. Finally, it's 2010, this would make an awesome HTML5 app instead of being written in Flash.

"Don't ask to ask" is also relevant for chatrooms: https://sol.gfxile.net/dontask.html

Just imagine what would happen if you tried to start a newcomer with Vulkan. (http://sol.gfxile.net/temp/hellotriangle.png)

I'm bemused by the concept of this "single page with dedicated domain name explaining a concept in three short paragraphs". Especially because this one claims at the bottom that it was mostly taken from here: http://sol.gfxile.net/dontask.html So... why not just link to that page? Why register a domain and pretty much copy-paste that content? I'm not trying to be inflammatory, just trying to understand this concept. Do people share these links with others or is it just for Hacker News credo?

I have a friend leading the IT team in a company of ~300, and he goes nuts if people keep probing him with "are you here?". He's a very chill person, but the problem was getting out of hand, so he started pasting users back with just a link to a page explaining why one does not simply do that. Some people took offense, but mostly the situation improved. It was along the lines of [1], but not sure if it's exactly the same. [1] https://sol.gfxile.net/dontask.html

GalaXQL http://sol.gfxile.net/g3/ is a decent, but very basic, introduction slightly held back by its reliance on sqlite.

I would try: First One Hour: https://www.khanacademy.org/computing/hour-of-code/hour-of-sql/v/welco… Also these two seem decent: http://sol.gfxile.net/galaxql.html http://sql.learncodethehardway.org/ The Hard Way has semi-decient issues. I would say SQL is easy to learn and would take only a few days to get the basics and than just learn as you come to stuff your missing. SQL is a very tiny language.

It reminds me of the interactive SQL tutorial GalaXQL. [GalaXQL](http://sol.gfxile.net/galaxql.html)

I had to look up what "immediate mode" means -- http://sol.gfxile.net/imgui/ discussion at http://lambda-the-ultimate.org/node/4561 Add to https://github.com/rust-lang/rust/wiki/Community-libraries#gui ?

If the correct URL is http://iki.fi/sol/imgui/ why does it redirect to http://sol.gfxile.net/imgui/? Should be the opposite.

I'd read up on the concepts behind Immediate Mode GUIs; here's a handy tutorial: http://sol.gfxile.net/imgui/ You trade some flexibility and input latency for a simple imperative structure that is easy to implement.

I think it's crazy how one guy's static interpolation curves (http://www.robertpenner.com/easing/) keep showing up verbatim in an ever increasing array of tweening frameworks over a decade since he first posted them. These interpolation curves can be nice in a pinch, but like I said before, the curves the curves are static, and so you can run into problems if you want to interrupt an action with another, or layer multiple tweens together. One particularly effective way to get natural eased motion is to use a function that outputs something like the movement of a simple damped harmonic spring. With a system like this, you specify a target position relative to the current position, the sponginess of the spring, and the speed of which it oscillates. This can give you very natural results and feels a lot closer to a real physical system than a lot of these interpolation curves (EaseInOutExp, etc). Here's some code for a damped spring system that can work really well as an alternative to predefined tween curves in user interfaces and games: http://www.ryanjuckett.com/programming/damped-springs/ And for more non-Penner interpolation alternatives, check out: http://sol.gfxile.net/interpolation/

Name the games. There are plenty of DirectDraw wrappers fixing old games https://www.nongnu.org/wined3d/ https://fdossena.com/?p=wined3d/index.frag http://dege.freeweb.hu/ https://github.com/CnCNet/cnc-ddraw https://github.com/elishacloud/dxwrapper https://sol.gfxile.net/ddhack/index.html even Win10 ships with own ddraw.dll wrapper.

I first got introduced to the concept by his talk, and this implementation here - http://sol.gfxile.net/imgui/ch01.html (latest archive I could find - https://web.archive.org/web/20200428143845/http://sol.gfxile.net/imgui… I've did some translations of the above C/C++ code to lua longtime here (actually luajit, as it requires the FFI) - https://github.com/malkia/ufo/blob/master/samples/SDL/imgui/ch01.lua (simplest example) through https://github.com/malkia/ufo/blob/master/samples/SDL/imgui/ch07.lua though my hack for C/C++'s __LINE__ macro was local function GEN_ID() return CURRENT_LINE() end e.g. you basically tie the state to the... ahem.. source code line (you need really something unique). Obviously Dear ImGUI has better approaches there (use the widget's contents, like text/label contents, or add your own with ##).

Here are some other SQL Learning resources I have collected in my note taking TiddlyWiki (mostly from HN itself). Interactive SQL Tutorials : ▪ Chartio Interactive PostgreSQL SQL Tutorial - https://chartio.com/learn/sql/ ▪ Select STAR SQL - https://selectstarsql.com/ ▪ SQL Bolt - Learn SQL with simple, interactive exercises - https://sqlbolt.com/ ▪ SQL Window functions - https://www.windowfunctions.com/ ▪ PostgreSQL Exercises - https://pgexercises.com/ ▪ SQL Zoo - http://sqlzoo.net/ ▪ SQL Teaching - https://www.sqlteaching.com/ ▪ ByteScout SQL Trainer - Use live data to train - https://app.bytescout.com/sql-trainer/index.html ▪ Schemaverse - A space-based strategy game implemented entirely within a PostgreSQL database - https://schemaverse.com/ ▪ Oracle Live SQL - Lerarn and share SQL - https://livesql.oracle.com/ ▪ GalaXQL 3.0 - an intractive tutorial with exploring the galaxy - http://sol.gfxile.net/g3/ ▪ SQL Exercises - http://sql-ex.ru/index.php