ptrott2017

StandardML is a rather nice modular high level functional programming language with algebraic datatypes, pattern matching, compile-time type checking and type inference etc. Poly/ML extends this with strong proven multi-core and cross platform support including Posix threads, parallel garbage collection, FFI etc. Poly/ML has been around a while, but it is still actively maintained by Dave Mathews et al (most recent release June 2026) has good windows and X11 support. Poly/ML is a great way to explore the world of StandardML and is used to build Isabelle and HOL theorem provers. Definitely worth a look!

Not eries (obviously) but if you switch out shareholder for stakeholder i.e. maximise stakeholder value, you gain a wider set of responsibilities more aligned with Eric's comment. This is in itself not a new idea, it partly emerged out of the work of R. Edward Freeman. His original book on stakeholder management was published in 1984 and over the last decade has become at least a regular discussion topic at many business schools. However, the idea needs to gain far more momentum. Hopeful Eric Reis's new book also helps move the discussions forward - looking forward to reading it.

@atomicnature - thank you for posting this. I saw the title and wondered if it was books on lean startups or lean manufacturing, very happy to find a collection of links to books on the Lean programming language (and the rest of the site is well worth a read). This made my morning!

Valid concern which should not be downvoted. For some this will be too early to garner interest or confidence. For others, especially those interested in the Pascal language family or building a compiled language with QBE, there is a lot of things in this project that justify taking a close look. (Not least of all, Graeme's proven track record in the Pascal community). Glad the project is getting some deserved attention and looking forward to seeing how it evolves.

You can use Lazarus from a C interface - via liblcl. There are bindings for Go and Nim that use this method. Given the QBE backend, this may be one possible route for Blaise but needs investigation.

Historic crane populations crashed due to hunting and then loss of habitat as wetlands were drained and agriculture and housing expanded etc. Today you can find cranes in the wild in Norfolk, Suffolk and the Fens district which are all regions with sizeable wetland habitats due to active protection and reintroduction programs. There are small groups of other breeding pairs elsewhere in the UK as well. See following for a quick backgrounder:

https://www.rspb.org.uk/whats-happening/news/the-great-crane...

and if you want some additional explanation:

https://aplwiki.com/wiki/Conway%27s_Game_of_Life

Factor provides support for both file and image based workflows. Factor is image-based and uses files when sharing, loading or refreshing vocabularies. however, just like lisp and Smalltalk, you can also save, share and restore system state via an image. For example you can save the whole state of Factor with the word

save-image

and you can restore that image using ./factor -i=path-to-image

This image workflow and interaction via the inspector provides a very similar workflow experience to both Smalltalk and Common Lisp.

Not the OP but suspect the source is this:

https://www.cso.ie/en/releasesandpublications/ep/p-cpr/censu...

For those outside US where content is currently not available at your location:

https://www.youtube.com/watch?v=451xJqNGFqU

22+ odd years ago I emailed Ross out of the blue. At the time I was working at a small startup attempting to build mobile banking infrastructure for rural poor in South Africa and elsewhere. I was after a copy of a paper he had mentioned in a talk and Ross replied with a blunt to the point email about how hard he thought the problem domain we were trying to tackle was (along with a pointer to the paper I had asked about). I remember being slightly annoyed by the initial tone of his response, but it got me thinking - then thinking a lot more. There were some very well thought out reasons behind his arguments. I replied a few days later with a detailed list of how we were addressing his concerns along with some others he hadn't mentioned but also acknowledging the areas we needed to dig into further. I didn't really expect an answer, after all, I didn't know him, but he had got me to think hard on key problems and I wanted to acknowledge that.

We got a lot more than a simple reply. We got his focused feedback, constructive criticisms, pointers to other work he thought was relevant, general support, some key follow up conversations on the phone, followed by introductions to folks he knew in industry who he thought could help (who would have never entertained us at that stage otherwise). While the startup eventually didn't make it, many of the ideas we worked on did. Of the folks that we met through that whole adventure, Ross was one of the standouts. Yup, he was very good people indeed and will be sadly missed!

Blender Apps are on the medium to long term plans for the Blender foundation (i.e. planned on roadmap but not currently under active development). The Blender team currently have a lot of projects on and are resource bound so have prioritized focus on finishing developments such as Evee Next, GPU compositing etc before starting other projects such as Apps.

For more detail see: https://www.blender.org/development/projects-to-look-forward...

This is very cool - recommend checking out the demo and examples:

https://glisp.app/commit:e7fbaae/

- its a very nice UI experience - try hello world then move the circle and see the code update automatically.

If you are interested in lisp and creative coding this is well worth experimenting with - really nice work!

I found the docs a better starting point:

https://docs.lucidarch.dev/

https://docs.lucidarch.dev/concept/

https://docs.lucidarch.dev/principles/

https://docs.lucidarch.dev/micro-vs-monolith/

Super excited to see this and thanks Mikhaed for posting!

Intel's Loihi and Manchester's APT SpiNNaker (http://apt.cs.manchester.ac.uk/projects/SpiNNaker/hardware/) are two extremely interesting projects and architectures that could drive new generation of machine learning apps (and migrate software based models into hardware)

Very much hoping Loihi2 (and a SpiNNaker descendent) will be eventually packaged into a format that enables researches and devs to start embedding it into systems though sadly looks like that wont be till late 2023 or more likely 2023 for Lohi2 at earliest. Still great to see progress.

Anton Commissaris was one of the founding team at Mint - now part of Intuit. His recent book: Mint - The Arc of the valley (https://www.amazon.com/ARC-VALLEY-Silicon-Soaring-Success/dp...) is an insider’s view of the entire journey from start up through acquisition. As an engineer have you ever wondered what BizDev does? Or have you wondered what it is like building a company that everyone thinks could be a unicorn for plans to change for the most unexpected of reasons? Or what the inside of an acquisition process looks like? While the Arc of the Valley gives great insight to all these questions - its far more than that it is a great read about a pioneering startup and everything that happened there.

Great to see this - Barrelfish is a very interesting OS and its really good to see ETH Zurich continue its history of creating original intriguing hardware for research and teaching. Hopefully Enzian can can get enough traction in the R&D community to enable wider interest.

As it says on the website: Oberon+ is fast statically typed, compiled, general-purpose, procedural, object-oriented, garbage collected programming language in the Pascal tradition, with support for generic programming.

Syntax wise it will be familiar to anyone who has used Pascal or Lua. Semantically it will feel familiar to anyone who has used Go. Its a lot of fun to use and leverages some of the nice aspects of Oberon matched with the performance of LuaJit, with some elegant extensions.

The IDE is easy to use and the code base is fun to work through. The examples give a great idea of the language and speed. Both code written in Oberon+ and the core IDE /compiler src code are very easy to read. There are lots of good ideas in here worth exploring further.

Rochus Keller the developer behind Oberon+ has a lot of interesting projects on his Github site which warrant further investigation but Oberon+ is especially worth exploring.

Leonid Zamdborg et al published a good paper on this a few years ago and it has a very good overview of related previous work. All the referenced papers in the background and related works section are all worth reading:

https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4353400/

the online simulator is worth playing with to get an idea of the functionality and code on github makes for an interesting read. fantastic project.

Commercial per node. There are also maintenance licenses etc as per most other commercial renderers

You can also rent 10 nodes per week fot $50 (for example rendering on multiple nodes in a small render farm)

For non-commercial there is a free-non-commercial license so you can learn how to use it at no cost.

Renderman 24 which is currently in beta and planned for release in 2021 will support Blender as a full authoring 'bridge' tool (same as Maya, Houdini and Katana).

It does and with acknowledgement that Conway's life was then the best known example of 2D cellular automata. However, Conway's life CA was not the focus of the article hence limited references to it. There was an increasing of interest at the time of the article on self similarity, emergence, self organization and mapping of CAs with dynamical systems theory and different classes of CAs (focus of article) beyond the game of life. A number of researchers at the time were interested in using CAs as a means of simulating certain dynamical systems e.g. fluids and weather. However generally the early work of CA pioneers including Stanislaw Ulam, Kondrad Zuse, Art Burks et all was not as widely known as it is now and certainly John Conway's life along with the works of Edward Frenkin, Norman Magulis et al and articles such as these by Stephen Wolfram helped generated renewed interest in the field. Without articles like this one I am not sure we would have seen sufficient interest to publish discoveries such as Christopher Langton's wonderful Loops and Ant only a few years later. If you are interested in CAs its a good article and worth reading.

Nope not a tutorial - but the code is nice and clear making it easy to work through and make changes/ add features in as a good learning exercise. The Lite editor plugins also give a good modular way to understand how specific features are implemented and to experiment with etc. The implementation overview (linked in post above) gives a great understanding of what is happening where. Overall its a really nice starting point for playing with the code base and thinking about how to extend or modify for your own use.

Sciter has been around a while and has a good reputation amongst those who have used the SDK. The OP also has a good reputation amongst devs and hackers who are familiar with his work. Its just not well known outside those circles. Rather than a red flag I don't see this as any different to when Blender needed to raise 100K Euro to originally go open source.

yeah i just found the kickstarter when I was replying to this thread. Off to go and sign up for it now...

C-smile (OP) ported Fabrice Bellard's gcc code to standard C (without gcc extensions).

The Sciter engine currently uses TIScript - a language c-smile orginally developed and the kickstarter proposal is to open source Sciter as is, then replace TIScript with the QuickJS engine. (TIScript is a very nice scripting language in itself that is easily picked up by JS devs)

The standard C version of QuickJS can be compiled using visual studio on windows as can be seen in this repo: https://github.com/c-smile/quickjspp

(Edit to update to latest repo)

Sciter is a very nice engine with a solid API/SDK and rock solid engineering behind it. For developers building efficient UI apps it can be a real alternative method to things like electron or as a lighter alternative to QT with QML script. However until now it was only available under commercial licence.

Andrew Fedoniouk ( a.k.a. c-smile Sciter's original developer) has a kickstarter to fund open sourcing and supporting additional development to make it more accessible javascript developers. Learn more here:

https://www.kickstarter.com/projects/c-smile/open-source-sci...

@cgay be great to see this integrated with the OpenDylan homepage (interactive examples) and a nice blog write up on how it works on the news/articles section. Very cool.

If you include the ticket ID e.g. [ticket-id] in the commit's description, the commit will automatically be linked to that ticket. You can view the list of all associated commits with a ticket by clicking the 'Check-ins' menu item on the ticket's page. When an item is closed - the link appears struck-thru.

I dont automatically close tickets on commits - since our workflow is commits get reviewed before closing an item- but it is straight forward to write a small few line script to do this if thats your workflow.