Jari Komppa

>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…

> 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.

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.

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/

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

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/ch01.html)

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 ##).