US Gov Issues Supply Chain Security Guidance for Software Suppliers https://www.securityweek.com/us-gov-issues-supply-chain-security-guidance-software-suppliers
The Cybersecurity and Infrastructure Security Agency (CISA), the National Security Agency (NSA), and the Office of the Director of National Intelligence (ODNI) this week released the second part of a three-part joint guidance on securing the software supply chain.
Created by the Enduring Security Framework (ESF), a cross-sector working group seeking to mitigate the risks threatening the critical infrastructure and national security, the guidance provides recommendations for developers, suppliers, and organizations.
In September, the three US agencies released the first part of the series, which included recommendations for developers looking to improve the software supply chain’s security.
US Gov Issues Guidance for Developers to Secure Software Supply Chain https://www.securityweek.com/us-gov-issues-guidance-developers-secure-software-supply-chain
Three U.S. government agencies — Cybersecurity and Information Security Agency (CISA), the National Security Agency (NSA) and the Office of the Director of National Intelligence (ODNI) — have announced the release of the first part of a three-part joint guidance on securing the software supply chain.
C++ and Java follow a traditional object-oriented programming (OOP) approach that uses a hierarchical class structure with inheritance for objects. They both support abstract classes to provide interface definitions. We won’t delve into these details as they get quite complex; instead, we’ll examine how Rust provides modular programming support since it doesn’t follow the OOP architecture.
Rust doesn’t have classes, rather it has traits. Check out Reading Rust for C Programmers if you haven’t scanned any Rust code.
Microsoft 3D Movie Maker—released originally in 1995—still has a small but active enthusiast user base that is still putting out content we would politely describe as “surreal.”
Among other things, the software introduced us all to Comic Sans.
We asked Hanselman why Microsoft was taking the trouble to put the 3D Movie Maker code out there after all these years.
“Because there’s never been an app like it,” Hanselman told Ars. “Even now 25 years later, there is a community excited about this tool.” He’s not wrong. 3D Movie Maker still has a small but active enthusiast user base that is still putting out content I would politely describe as “surreal.”
Open-sourcing the app could lead to all kinds of experimental forked versions, but Turing has specific updates that they also plan to release under an open source license. These improvements will include updated versions of the BRender engine and 3D Movie Maker that run natively on modern systems, and a “3D Movie Maker Plus” that removes the app’s 256 color limit, improves audio support, adds native video export features, and more. The goal will be to expand the software’s feature set while “keep[ing] it as simple and easy to use as the original.”
3D Movie Maker has one more dubious accomplishment to its name: Dialog boxes in 3D Movie Maker are the first documented appearance of Comic Sans, which was developed for Microsoft Bob but wasn’t ready when that software shipped. Comic Sans later conquered office signage everywhere thanks to its inclusion in the Windows 95 Plus! Pack, Internet Explorer, and other ’90s-era Microsoft products.
Programmer and lawyer Matthew Butterick has sued Microsoft, GitHub, and OpenAI, alleging that GitHub’s Copilot violates the terms of open-source licenses and infringes the rights of programmers.
GitHub Copilot, released in June 2022, is an AI-based programming aid that uses OpenAI Codex to generate real-time source code and function recommendations in Visual Studio.
The tool was trained with machine learning using billions of lines of code from public repositories and can transform natural language into code snippets across dozens of programming languages.
Clipping authors out
While Copilot can speed up the process of writing code and ease software development, its use of public open-source code has caused experts to worry that it violates licensing attributions and limitations.
Open-source licenses, like the GPL, Apache, and MIT licenses, require attribution of the author’s name and defining particular copyrights.
However, Copilot is removing this component, and even when the snippets are longer than 150 characters and taken directly from the training set, no attribution is given.
FREELANCE-OHJELMISTOKEHITTÄJÄN OPAS
Oman yrityksen perustaminen voi jännittää: Mistä tiedän, että töitä riittää? Mitä itse laatimani sopimuspohjan tulee sisältää? Miten yritykseni talousasiat hoituvat? Muun muassa nämä kiperät kysymykset askarruttavat freelance-ohjelmistokehittäjäksi ryhtymistä harkitsevien mieliä. https://witted.com/freelance-ohjelmistokehitt%C3%A4j%C3%A4n-opas
YOU’D EXPECTthe longest and most costly phase in the lifecycle of a software product to be the initial development of the system, when all those great features are first imagined and then created. In fact, the hardest part comes later, during the maintenance phase. That’s when programmers pay the price for the shortcuts they took during development.
So why did they take shortcuts? Maybe they didn’t realize that they were cutting any corners. Only when their code was deployed and exercised by a lot of users did its hidden flaws come to light. And maybe the developers were rushed. Time-to-market pressures would almost guarantee that their software will contain more bugs than it would otherwise.
The struggle that most companies have maintaining code causes a second problem: fragility. Every new feature that gets added to the code increases its complexity, which then increases the chance that something will break. It’s common for software to grow so complex that the developers avoid changing it more than is absolutely necessary for fear of breaking something. In many companies, whole teams of developers are employed not to develop anything new but just to keep existing systems going. You might say that they run a software version of the Red Queen’s race, running as fast as they can just to stay in the same place.
It’s a sorry situation. Yet the current trajectory of the software industry is toward increasing complexity, longer product-development times, and greater fragility of production systems.
To address such issues, companies usually just throw more people at the problem: more developers, more testers, and more technicians who intervene when systems fail.
Surely there must be a better way. I’m part of a growing group of developers who think the answer could be functional programming. Here I describe what functional programming is, why using it helps, and why I’m so enthusiastic about it.
With functional programming, less is more
Another complexity monster lurking in the software quagmire is called a null reference, meaning that a reference to a place in memory points to nothing at all. If you try to use this reference, an error ensues. So programmers have to remember to check whether something is null before trying to read or change what it references.
Nearly every popular language today has this flaw. The pioneering computer scientist Tony Hoare introduced null references in the ALGOL language back in 1965, and it was later incorporated into numerous other languages. Hoare explained that he did this “simply because it was so easy to implement,” but today he considers it to be a “billion-dollar mistake.” That’s because it has caused countless bugs when a reference that the programmer expects to be valid is really a null reference.
Software developers need to be extremely disciplined to avoid such pitfalls, and sometimes they don’t take adequate precautions.
History is proof that removing a dangerous feature can greatly improve the quality of code. Today, we have a slew of dangerous practices that compromise the robustness and maintainability of software. Nearly all modern programming languages have some form of null references, shared global state, and functions with side effects—things that are far worse than the GOTO ever was.
How can those flaws be eliminated? It turns out that the answer has been around for decades: purely functional programming languages.
The first purely functional language to become popular, called Haskell, was created in 1990. So by the mid-1990s, the world of software development really had the solution to the vexing problems it still faces. Sadly, the hardware of the time often wasn’t powerful enough to make use of the solution. But today’s processors can easily manage the demands of Haskell and other purely functional languages.
Indeed, software based on pure functions is particularly well suited to modern multicore CPUs. That’s because pure functions operate only on their input parameters, making it impossible to have any interactions between different functions. This allows the compiler to be optimized to produce code that runs on multiple cores efficiently and easily.
As the name suggests, with purely functional programming, the developer can write only pure functions, which, by definition, cannot have side effects. With this one restriction, you increase stability, open the door to compiler optimizations, and end up with code that’s far easier to reason about.
But what if a function needs to know or needs to manipulate the state of the system? In that case, the state is passed through a long chain of what are called composed functions—functions that pass their outputs to the inputs of the next function in the chain. By passing the state from function to function, each function has access to it and there’s no chance of another concurrent programming thread modifying that state—another common and costly fragility found in far too many programs.
Functional programming also has a solution to Hoare’s “billion-dollar mistake,” null references. It addresses that problem by disallowing nulls. Instead, there is a construct usually called Maybe (or Option in some languages). A Maybe can be Nothing or Just some value. Working with Maybes forces developers to always consider both cases. They have no choice in the matter. They must handle the Nothing case every single time they encounter a Maybe. Doing so eliminates the many bugs that null references can spawn.
Functional programming also requires that data be immutable, meaning that once you set a variable to some value, it is forever that value. Variables are more like variables in math. For example, to compute a formula, y = x2 + 2x – 11, you pick a value for x and at no time during the computation of y does x take on a different value. So, the same value for x is used when computing x2 as is used when computing 2x. In most programming languages, there is no such restriction.
Unlike most languages, functional programming languages are deeply rooted in mathematics. It’s this lineage in the highly disciplined field of mathematics that gives functional languages their biggest advantages.
Why is that? It’s because people have been working on mathematics for thousands of years. It’s pretty solid. Most programming paradigms, such as object-oriented programming, have at most half a dozen decades of work behind them. They are crude and immature by comparison.
Let me share an example of how programming is sloppy compared with mathematics. We typically teach new programmers to forget what they learned in math class when they first encounter the statement x = x + 1. In math, this equation has zero solutions. But in most of today’s programming languages, x = x + 1 is not an equation. It is a statement that commands the computer to take the value of x, add one to it, and put it back into a variable called x.
In functional programming, there are no statements, only expressions.
Thanks to functional purity, you can reason about code using algebraic substitution to help reduce code complexity in the same way you reduced the complexity of equations back in algebra class. In non-functional languages (imperative languages), there is no equivalent mechanism for reasoning about how the code works.
Functional programming has a steep learning curve
Pure functional programming solves many of our industry’s biggest problems by removing dangerous features from the language, making it harder for developers to shoot themselves in the foot. At first, these limitations may seem drastic, as I’m sure the 1960s developers felt regarding the removal of GOTO. But the fact of the matter is that it’s both liberating and empowering to work in these languages—so much so that nearly all of today’s most popular languages have incorporated functional features, although they remain fundamentally imperative languages.
The biggest problem with this hybrid approach is that it still allows developers to ignore the functional aspects of the language.
But functional programming isn’t a bed of roses. It comes at a cost. Learning to program according to this functional paradigm is almost like learning to program again from the beginning. In many cases, developers must familiarize themselves with math that they didn’t learn in school. The required math isn’t difficult—it’s just new and, to the math phobic, scary.
More important, developers need to learn a new way of thinking. At first this will be a burden, because they are not used to it. But with time, this new way of thinking becomes second nature and ends up reducing cognitive overhead compared with the old ways of thinking. The result is a massive gain in efficiency.
But making the transition to functional programming can be difficult.
Microsoft has urged developers still using the long-term support (LTS) release of .NET Core 3.1 to migrate to the latest .NET Core versions until it reaches the end of support (EOS) next month.
The company warned customers on the Windows message center to upgrade to .NET 6 (LTS) or .NET 7 “as soon as possible” before .NET Core 3.1 (LTS) reaches EOS on December 13, 2022.
GitHub Copilot dubs itself as an “AI pair programmer” for software developers, automatically suggesting code in real time. According to GitHub, Copilot is “powered by Codex, a generative pretrained AI model created by OpenAI” and has been trained on “natural language text and source code from publicly available sources, including code in public repositories on GitHub.”
However, a class-action lawsuit filed against GitHub Copilot, its parent company Microsoft, and OpenAI claims open-source software piracy and violations of open-source licenses. Specifically, the lawsuit states that code generated by Copilot does not include any attribution of the original author of the code, copyright notices, and a copy of the license, which most open-source licenses require.
Many of you will have heard of the esoteric programming language Brainf**k_. It’s an example language that’s nearly impossible to use because it’s too simple. It’s basically a Turing computer in code – you can essentially put characters into an array, read them out, increment, decrement, and branch. The rest is up to you. Good luck!
What could be worse? Befunge, a language that parses code not just left-to-right or top-to-bottom, but in any direction depending on the use of ^, v, >, and <. (We love the way that GOTO 10 looks like a garden path in the example.)
While JavaScript might not be the ideal language to write a production compiler, you might enjoy the “Create Your Own Compiler” tutorial that does an annotated walkthrough of “The Super Tiny Compiler” and teaches you the basics of writing a compiler from scratch.
The super tiny compiler itself is about 200 lines of code. The source code is well, over 1,000 but that’s because of the literate programming comments. The fancy title comments are about half as large as the actual compiler.
[Georgi Gerganov] recently shared a great resource for running high-quality AI-driven speech recognition in a plain C/C++ implementation on a variety of platforms. The automatic speech recognition (ASR) model is fully implemented using only two source files and requires no dependencies. As a result, the high-quality speech recognition doesn’t involve calling remote APIs, and can run locally on different devices in a fairly straightforward manner. The image above shows it running locally on an iPhone 13, but it can do more than that.
[Georgi]’s work is a port of OpenAI’s Whisper model, a remarkably-robust piece of software that does a truly impressive job of turning human speech into text. Whisper is easy to set up and play with, but this port makes it easier to get the system working in other ways.
[P B Richards] and [Aaron Flin] were bemoaning the resource hunger of modern JavaScript environments and planned to produce a system that was much stingier with memory and CPU, that would fit better on lower-end platforms. Think Nginx, NodeJS, and your flavour of database and how much resource that all needs to run properly. Now try wedge that lot onto a Raspberry Pi Zero. Well, they did, creating Rampart: a JavaScript-based complete stack development environment.
Maintenance of the software that’s used for the hardest physics calculations rests almost entirely with a retiree. The situation reveals the problematic incentive structure of academia.
Google: After using Rust, we slashed Android memory safety vulnerabilities https://www.zdnet.com/article/google-after-using-rust-we-slashed-android-memory-safety-vulnerabilities/
Google’s decision to use Rust for new code in Android in order to reduce memory-related flaws appears to be paying off. Memory safety vulnerabilities in Android have been more than halved — a milestone that coincides with Google’s switch from C and C++ to the memory-safe programming language, Rust. This is the first year that memory safety vulnerabilities are not the biggest category of security flaws, and comes a year after Google made Rust the default for new code in the Android Open Source Project (AOSP).
Back in the late 1970s and early 1980s, engineering students would take a few semesters of drafting and there would usually be a week or two of “computer-aided drafting.” In those days, that meant punching cards that said RECTANGLE 20,30 or something like that and getting the results on a plotter. Then we moved on to graphical CAD packages, but lately, some have gone back to describing rather than drawing complex designs. Cornell University researchers are trying to provide the same options for coding. They’ve built a Juypter notebook extension called Notate that allows you to sketch and handwrite parts of programs that interact with traditional computer code. You can see a video about the work below.
Kyle Wiggers / TechCrunch:
GitHub launches Copilot for Business, with corporate licensing and policy controls, for $19/user per month, and claims it won’t store or share companies’ code — GitHub Copilot, GitHub’s service that intelligently suggests lines of code, is now available in a plan for enterprises months …
We use cookies to ensure that we give you the best experience on our website. If you continue to use this site we will assume that you are happy with it.
We are a professional review site that has advertisement and can receive compensation from the companies whose products we review. We use affiliate links in the post so if you use them to buy products through those links we can get compensation at no additional cost to you.OkDecline
768 Comments
Tomi Engdahl says:
https://etn.fi/index.php/13-news/14184-neljae-ohjelmointikieltae-repii-kaulaa-muihin
Tomi Engdahl says:
TIOBE-indeksi mittaa ohjelmointikielten suosiota verkkohakujen perusteella. Listalla Python, Java, C ja C++ ovat muodostaneet neljän kärjen jo jonkin aikaa. Näiden kielten suosio on omassa luokassaan ja ero muihin näyttää vain kasvavan.
https://etn.fi/index.php/13-news/14184-neljae-ohjelmointikieltae-repii-kaulaa-muihin
Tomi Engdahl says:
US Gov Issues Supply Chain Security Guidance for Software Suppliers
https://www.securityweek.com/us-gov-issues-supply-chain-security-guidance-software-suppliers
The Cybersecurity and Infrastructure Security Agency (CISA), the National Security Agency (NSA), and the Office of the Director of National Intelligence (ODNI) this week released the second part of a three-part joint guidance on securing the software supply chain.
Created by the Enduring Security Framework (ESF), a cross-sector working group seeking to mitigate the risks threatening the critical infrastructure and national security, the guidance provides recommendations for developers, suppliers, and organizations.
In September, the three US agencies released the first part of the series, which included recommendations for developers looking to improve the software supply chain’s security.
US Gov Issues Guidance for Developers to Secure Software Supply Chain
https://www.securityweek.com/us-gov-issues-guidance-developers-secure-software-supply-chain
Three U.S. government agencies — Cybersecurity and Information Security Agency (CISA), the National Security Agency (NSA) and the Office of the Director of National Intelligence (ODNI) — have announced the release of the first part of a three-part joint guidance on securing the software supply chain.
Tomi Engdahl says:
The ‘Viral’ Secure Programming Language That’s Taking Over Tech
Rust makes it impossible to introduce some of the most common security vulnerabilities. And its adoption can’t come soon enough.
https://www.wired.com/story/rust-secure-programming-language-memory-safe/
Tomi Engdahl says:
https://www.raspberrypi.com/news/make-your-own-pixel-editing-program-wireframe-68/
Tomi Engdahl says:
“In C++ it’s harder to shoot yourself in the foot, but when you do, you blow off your whole leg. ”
– Bjarne Stroustrup, C++’s creator.
Source:
https://www.facebook.com/126000117413375/posts/pfbid02gQGRPikKhoDYm8xvYhjzY4h549idGmce1MJ2mpGwCjzWjS9MkjoTtTs7wTEds4Fwl/
Tomi Engdahl says:
https://etn.fi/index.php/13-news/14223-suurin-osa-koodaajien-ajasta-kuluu-testaamiseen
Tomi Engdahl says:
https://etn.fi/index.php/13-news/14222-outssystems-laajensi-mobiilisovelluksiin
Tomi Engdahl says:
An Objective Look at Rust
Oct. 12, 2022
Rather than implementing an object-oriented programming architecture, the Rust language offers modular programming support, using traits rather than classes.
https://www.electronicdesign.com/blogs/altembedded/article/21252370/electronic-design-an-objective-look-at-rust?utm_source=EG+ED+Connected+Solutions&utm_medium=email&utm_campaign=CPS221103038&o_eid=7211D2691390C9R&rdx.identpull=omeda|7211D2691390C9R&oly_enc_id=7211D2691390C9R
C++ and Java follow a traditional object-oriented programming (OOP) approach that uses a hierarchical class structure with inheritance for objects. They both support abstract classes to provide interface definitions. We won’t delve into these details as they get quite complex; instead, we’ll examine how Rust provides modular programming support since it doesn’t follow the OOP architecture.
Rust doesn’t have classes, rather it has traits. Check out Reading Rust for C Programmers if you haven’t scanned any Rust code.
Reading Rust for C Programmers
March 11, 2022
Here’s a very short intro to the syntax for Rust, the up-and-coming programming language in the embedded space.
https://www.electronicdesign.com/blogs/altembedded/article/21235152/electronic-design-reading-rust-for-c-programmers
Tomi Engdahl says:
Microsoft 3D Movie Maker—released originally in 1995—still has a small but active enthusiast user base that is still putting out content we would politely describe as “surreal.”
Microsoft open-sourced the code for 1995’s 3D Movie Maker because someone asked [Updated]
https://arstechnica.com/gadgets/2022/05/microsoft-open-sourced-the-code-for-1995s-3d-movie-maker-because-someone-asked/?utm_source=facebook&utm_brand=ars&utm_social-type=owned&utm_medium=social
Among other things, the software introduced us all to Comic Sans.
We asked Hanselman why Microsoft was taking the trouble to put the 3D Movie Maker code out there after all these years.
“Because there’s never been an app like it,” Hanselman told Ars. “Even now 25 years later, there is a community excited about this tool.” He’s not wrong. 3D Movie Maker still has a small but active enthusiast user base that is still putting out content I would politely describe as “surreal.”
Open-sourcing the app could lead to all kinds of experimental forked versions, but Turing has specific updates that they also plan to release under an open source license. These improvements will include updated versions of the BRender engine and 3D Movie Maker that run natively on modern systems, and a “3D Movie Maker Plus” that removes the app’s 256 color limit, improves audio support, adds native video export features, and more. The goal will be to expand the software’s feature set while “keep[ing] it as simple and easy to use as the original.”
3D Movie Maker has one more dubious accomplishment to its name: Dialog boxes in 3D Movie Maker are the first documented appearance of Comic Sans, which was developed for Microsoft Bob but wasn’t ready when that software shipped. Comic Sans later conquered office signage everywhere thanks to its inclusion in the Windows 95 Plus! Pack, Internet Explorer, and other ’90s-era Microsoft products.
Tomi Engdahl says:
Microsoft sued for open-source piracy through GitHub Copilot
https://www.bleepingcomputer.com/news/security/microsoft-sued-for-open-source-piracy-through-github-copilot/
Programmer and lawyer Matthew Butterick has sued Microsoft, GitHub, and OpenAI, alleging that GitHub’s Copilot violates the terms of open-source licenses and infringes the rights of programmers.
GitHub Copilot, released in June 2022, is an AI-based programming aid that uses OpenAI Codex to generate real-time source code and function recommendations in Visual Studio.
The tool was trained with machine learning using billions of lines of code from public repositories and can transform natural language into code snippets across dozens of programming languages.
Clipping authors out
While Copilot can speed up the process of writing code and ease software development, its use of public open-source code has caused experts to worry that it violates licensing attributions and limitations.
Open-source licenses, like the GPL, Apache, and MIT licenses, require attribution of the author’s name and defining particular copyrights.
However, Copilot is removing this component, and even when the snippets are longer than 150 characters and taken directly from the training set, no attribution is given.
Tomi Engdahl says:
https://learn.microsoft.com/en-us/windows/arm/apps-on-arm-x86-emulation
Tomi Engdahl says:
FREELANCE-OHJELMISTOKEHITTÄJÄN OPAS
Oman yrityksen perustaminen voi jännittää: Mistä tiedän, että töitä riittää? Mitä itse laatimani sopimuspohjan tulee sisältää? Miten yritykseni talousasiat hoituvat? Muun muassa nämä kiperät kysymykset askarruttavat freelance-ohjelmistokehittäjäksi ryhtymistä harkitsevien mieliä.
https://witted.com/freelance-ohjelmistokehitt%C3%A4j%C3%A4n-opas
Tomi Engdahl says:
WHY FUNCTIONAL PROGRAMMING SHOULD BE THE FUTURE OF SOFTWARE DEVELOPMENT
It’s hard to learn, but your code will produce fewer nasty surprises
https://spectrum.ieee.org/functional-programming
YOU’D EXPECTthe longest and most costly phase in the lifecycle of a software product to be the initial development of the system, when all those great features are first imagined and then created. In fact, the hardest part comes later, during the maintenance phase. That’s when programmers pay the price for the shortcuts they took during development.
So why did they take shortcuts? Maybe they didn’t realize that they were cutting any corners. Only when their code was deployed and exercised by a lot of users did its hidden flaws come to light. And maybe the developers were rushed. Time-to-market pressures would almost guarantee that their software will contain more bugs than it would otherwise.
Tomi Engdahl says:
https://spectrum.ieee.org/functional-programming
The struggle that most companies have maintaining code causes a second problem: fragility. Every new feature that gets added to the code increases its complexity, which then increases the chance that something will break. It’s common for software to grow so complex that the developers avoid changing it more than is absolutely necessary for fear of breaking something. In many companies, whole teams of developers are employed not to develop anything new but just to keep existing systems going. You might say that they run a software version of the Red Queen’s race, running as fast as they can just to stay in the same place.
It’s a sorry situation. Yet the current trajectory of the software industry is toward increasing complexity, longer product-development times, and greater fragility of production systems.
To address such issues, companies usually just throw more people at the problem: more developers, more testers, and more technicians who intervene when systems fail.
Surely there must be a better way. I’m part of a growing group of developers who think the answer could be functional programming. Here I describe what functional programming is, why using it helps, and why I’m so enthusiastic about it.
With functional programming, less is more
Another complexity monster lurking in the software quagmire is called a null reference, meaning that a reference to a place in memory points to nothing at all. If you try to use this reference, an error ensues. So programmers have to remember to check whether something is null before trying to read or change what it references.
Nearly every popular language today has this flaw. The pioneering computer scientist Tony Hoare introduced null references in the ALGOL language back in 1965, and it was later incorporated into numerous other languages. Hoare explained that he did this “simply because it was so easy to implement,” but today he considers it to be a “billion-dollar mistake.” That’s because it has caused countless bugs when a reference that the programmer expects to be valid is really a null reference.
Software developers need to be extremely disciplined to avoid such pitfalls, and sometimes they don’t take adequate precautions.
History is proof that removing a dangerous feature can greatly improve the quality of code. Today, we have a slew of dangerous practices that compromise the robustness and maintainability of software. Nearly all modern programming languages have some form of null references, shared global state, and functions with side effects—things that are far worse than the GOTO ever was.
How can those flaws be eliminated? It turns out that the answer has been around for decades: purely functional programming languages.
The first purely functional language to become popular, called Haskell, was created in 1990. So by the mid-1990s, the world of software development really had the solution to the vexing problems it still faces. Sadly, the hardware of the time often wasn’t powerful enough to make use of the solution. But today’s processors can easily manage the demands of Haskell and other purely functional languages.
Indeed, software based on pure functions is particularly well suited to modern multicore CPUs. That’s because pure functions operate only on their input parameters, making it impossible to have any interactions between different functions. This allows the compiler to be optimized to produce code that runs on multiple cores efficiently and easily.
As the name suggests, with purely functional programming, the developer can write only pure functions, which, by definition, cannot have side effects. With this one restriction, you increase stability, open the door to compiler optimizations, and end up with code that’s far easier to reason about.
But what if a function needs to know or needs to manipulate the state of the system? In that case, the state is passed through a long chain of what are called composed functions—functions that pass their outputs to the inputs of the next function in the chain. By passing the state from function to function, each function has access to it and there’s no chance of another concurrent programming thread modifying that state—another common and costly fragility found in far too many programs.
Functional programming also has a solution to Hoare’s “billion-dollar mistake,” null references. It addresses that problem by disallowing nulls. Instead, there is a construct usually called Maybe (or Option in some languages). A Maybe can be Nothing or Just some value. Working with Maybes forces developers to always consider both cases. They have no choice in the matter. They must handle the Nothing case every single time they encounter a Maybe. Doing so eliminates the many bugs that null references can spawn.
Functional programming also requires that data be immutable, meaning that once you set a variable to some value, it is forever that value. Variables are more like variables in math. For example, to compute a formula, y = x2 + 2x – 11, you pick a value for x and at no time during the computation of y does x take on a different value. So, the same value for x is used when computing x2 as is used when computing 2x. In most programming languages, there is no such restriction.
Unlike most languages, functional programming languages are deeply rooted in mathematics. It’s this lineage in the highly disciplined field of mathematics that gives functional languages their biggest advantages.
Why is that? It’s because people have been working on mathematics for thousands of years. It’s pretty solid. Most programming paradigms, such as object-oriented programming, have at most half a dozen decades of work behind them. They are crude and immature by comparison.
Let me share an example of how programming is sloppy compared with mathematics. We typically teach new programmers to forget what they learned in math class when they first encounter the statement x = x + 1. In math, this equation has zero solutions. But in most of today’s programming languages, x = x + 1 is not an equation. It is a statement that commands the computer to take the value of x, add one to it, and put it back into a variable called x.
In functional programming, there are no statements, only expressions.
Thanks to functional purity, you can reason about code using algebraic substitution to help reduce code complexity in the same way you reduced the complexity of equations back in algebra class. In non-functional languages (imperative languages), there is no equivalent mechanism for reasoning about how the code works.
Functional programming has a steep learning curve
Pure functional programming solves many of our industry’s biggest problems by removing dangerous features from the language, making it harder for developers to shoot themselves in the foot. At first, these limitations may seem drastic, as I’m sure the 1960s developers felt regarding the removal of GOTO. But the fact of the matter is that it’s both liberating and empowering to work in these languages—so much so that nearly all of today’s most popular languages have incorporated functional features, although they remain fundamentally imperative languages.
The biggest problem with this hybrid approach is that it still allows developers to ignore the functional aspects of the language.
But functional programming isn’t a bed of roses. It comes at a cost. Learning to program according to this functional paradigm is almost like learning to program again from the beginning. In many cases, developers must familiarize themselves with math that they didn’t learn in school. The required math isn’t difficult—it’s just new and, to the math phobic, scary.
More important, developers need to learn a new way of thinking. At first this will be a burden, because they are not used to it. But with time, this new way of thinking becomes second nature and ends up reducing cognitive overhead compared with the old ways of thinking. The result is a massive gain in efficiency.
But making the transition to functional programming can be difficult.
Tomi Engdahl says:
https://eloncodereview.com/
Tomi Engdahl says:
https://spectrum.ieee.org/the-rise-of-sql
Tomi Engdahl says:
https://techcrunch.com/2022/11/10/coefficient-live-data-excel-google-sheets-spreadsheets/
Tomi Engdahl says:
Kubernetes Patterns: Reusable elements for designing cloud-native applications
To make the most of the cloud, technologists must approach applications in new ways.
https://red.ht/34nMXxv #Kubernetes
Tomi Engdahl says:
https://linuxhint.com/run-arduino-code/
Tomi Engdahl says:
https://github.com/bxparks/EpoxyDuino
Tomi Engdahl says:
Microsoft urges devs to migrate away from .NET Core 3.1 ASAP
https://www.bleepingcomputer.com/news/security/microsoft-urges-devs-to-migrate-away-from-net-core-31-asap/
Microsoft has urged developers still using the long-term support (LTS) release of .NET Core 3.1 to migrate to the latest .NET Core versions until it reaches the end of support (EOS) next month.
The company warned customers on the Windows message center to upgrade to .NET 6 (LTS) or .NET 7 “as soon as possible” before .NET Core 3.1 (LTS) reaches EOS on December 13, 2022.
Tomi Engdahl says:
https://spectrum.ieee.org/art-of-code
Tomi Engdahl says:
Ownership of AI-Generated Code Hotly Disputed
A copyright storm may be brewing for AI pair programmer GitHub Copilot
https://spectrum.ieee.org/ai-code-generation-ownership
GitHub Copilot dubs itself as an “AI pair programmer” for software developers, automatically suggesting code in real time. According to GitHub, Copilot is “powered by Codex, a generative pretrained AI model created by OpenAI” and has been trained on “natural language text and source code from publicly available sources, including code in public repositories on GitHub.”
However, a class-action lawsuit filed against GitHub Copilot, its parent company Microsoft, and OpenAI claims open-source software piracy and violations of open-source licenses. Specifically, the lawsuit states that code generated by Copilot does not include any attribution of the original author of the code, copyright notices, and a copy of the license, which most open-source licenses require.
Tomi Engdahl says:
Two Esoteric Programming Languages, One Interpreter
https://hackaday.com/2022/11/19/two-esoteric-programming-languages-one-interpreter/
Many of you will have heard of the esoteric programming language Brainf**k_. It’s an example language that’s nearly impossible to use because it’s too simple. It’s basically a Turing computer in code – you can essentially put characters into an array, read them out, increment, decrement, and branch. The rest is up to you. Good luck!
What could be worse? Befunge, a language that parses code not just left-to-right or top-to-bottom, but in any direction depending on the use of ^, v, >, and <. (We love the way that GOTO 10 looks like a garden path in the example.)
Uniting the two, [rsheldiii] brings us BrainFunge, a Brainf**k_ interpreter written in Befunge.
https://github.com/rsheldiii/brainfunge
Tomi Engdahl says:
https://thenewstack.io/webassembly-needs-schedulers-and-kubernetes-doesnt-quite-fit-the-bill/
Tomi Engdahl says:
https://www.freecodecamp.org/news/javascript-let-and-const-hoisting/
https://thenewstack.io/webassembly-needs-schedulers-and-kubernetes-doesnt-quite-fit-the-bill/
Tomi Engdahl says:
TOP 10 PROGRAMMING LANGUAGES THAT SPACEX USES TO PROGRAM ROCKETS
https://www.analyticsinsight.net/top-10-programming-languages-that-spacex-uses-to-program-rockets/
Tomi Engdahl says:
https://hackaday.com/2022/11/27/create-a-compiler-step-by-step/
While JavaScript might not be the ideal language to write a production compiler, you might enjoy the “Create Your Own Compiler” tutorial that does an annotated walkthrough of “The Super Tiny Compiler” and teaches you the basics of writing a compiler from scratch.
The super tiny compiler itself is about 200 lines of code. The source code is well, over 1,000 but that’s because of the literate programming comments. The fancy title comments are about half as large as the actual compiler.
https://citw.dev/tutorial/create-your-own-compiler
Tomi Engdahl says:
Here’s A Plain C/C++ Implementation Of AI Speech Recognition, So Get Hackin’
https://hackaday.com/2022/11/27/heres-a-plain-c-c-implementation-of-ai-speech-recognition-so-get-hackin/
[Georgi Gerganov] recently shared a great resource for running high-quality AI-driven speech recognition in a plain C/C++ implementation on a variety of platforms. The automatic speech recognition (ASR) model is fully implemented using only two source files and requires no dependencies. As a result, the high-quality speech recognition doesn’t involve calling remote APIs, and can run locally on different devices in a fairly straightforward manner. The image above shows it running locally on an iPhone 13, but it can do more than that.
[Georgi]’s work is a port of OpenAI’s Whisper model, a remarkably-robust piece of software that does a truly impressive job of turning human speech into text. Whisper is easy to set up and play with, but this port makes it easier to get the system working in other ways.
https://github.com/ggerganov/whisper.cpp#whispercpp
Tomi Engdahl says:
https://hackaday.com/2022/11/26/interpreting-the-lua-interpreter/
Tomi Engdahl says:
Squish That Stack With Rampart
https://hackaday.com/2022/11/24/squish-that-stack-with-rampart/
[P B Richards] and [Aaron Flin] were bemoaning the resource hunger of modern JavaScript environments and planned to produce a system that was much stingier with memory and CPU, that would fit better on lower-end platforms. Think Nginx, NodeJS, and your flavour of database and how much resource that all needs to run properly. Now try wedge that lot onto a Raspberry Pi Zero. Well, they did, creating Rampart: a JavaScript-based complete stack development environment.
https://www.rampart.dev/
Tomi Engdahl says:
Comparing C to machine language
https://www.youtube.com/watch?v=yOyaJXpAYZQ
Tomi Engdahl says:
Lunastaakohan wasm mitä Java joskus lupasi? https://devclass.com/2022/11/25/wasmer-3-0-released/
Tomi Engdahl says:
https://hackaday.com/2022/12/01/tega-typescript-embedded-game-boy-macro-assembler/
https://bgb.bircd.org/
Tomi Engdahl says:
https://hackaday.com/2022/12/01/ask-hackaday-when-it-comes-to-processors-how-far-back-can-you-go/
Tomi Engdahl says:
The Ifs – Coding: it´s child’s play!
https://hackaday.io/project/167281-the-ifs-coding-its-childs-play
The Ifs are educational toys that teach girls and
boys how to code from the age of three.
Tomi Engdahl says:
Coding is Dead, Long Live Programming!
Low code and no code platforms are the talk of the town, but will they hold up in the future?
https://analyticsindiamag.com/coding-is-dead-long-live-programming/
Tomi Engdahl says:
TOP 10 PROGRAMMING LANGUAGES OF THE FUTURE: 2050 OUTLOOK
https://www.analyticsinsight.net/top-10-programming-languages-of-the-future-2050-outlook/
Tomi Engdahl says:
An open source developer’s guide to building applications
https://opensource.com/downloads/building-applications
Tomi Engdahl says:
https://www.theregister.com/2022/12/02/android_google_rust/
Tomi Engdahl says:
https://www.bleepingcomputer.com/news/technology/open-source-software-host-fosshost-shutting-down-as-ceo-unreachable/
Tomi Engdahl says:
https://www.freecodecamp.org/news/build-a-low-code-dashboard-for-your-startup/
Tomi Engdahl says:
https://hackaday.com/2022/12/03/better-coding-through-sketching/
Tomi Engdahl says:
Crucial Computer Program for Particle Physics at Risk of Obsolescence
By
MATT VON HIPPEL
December 1, 2022
https://www.quantamagazine.org/crucial-computer-program-for-particle-physics-at-risk-of-obsolescence-20221201/
Maintenance of the software that’s used for the hardest physics calculations rests almost entirely with a retiree. The situation reveals the problematic incentive structure of academia.
Tomi Engdahl says:
https://www.analyticsinsight.net/top-10-c-and-c-courses-that-will-secure-a-6-figure-job/
Tomi Engdahl says:
Google: After using Rust, we slashed Android memory safety vulnerabilities https://www.zdnet.com/article/google-after-using-rust-we-slashed-android-memory-safety-vulnerabilities/
Google’s decision to use Rust for new code in Android in order to reduce memory-related flaws appears to be paying off. Memory safety vulnerabilities in Android have been more than halved — a milestone that coincides with Google’s switch from C and C++ to the memory-safe programming language, Rust. This is the first year that memory safety vulnerabilities are not the biggest category of security flaws, and comes a year after Google made Rust the default for new code in the Android Open Source Project (AOSP).
Tomi Engdahl says:
Better Coding Through Sketching
https://hackaday.com/2022/12/03/better-coding-through-sketching/
Back in the late 1970s and early 1980s, engineering students would take a few semesters of drafting and there would usually be a week or two of “computer-aided drafting.” In those days, that meant punching cards that said RECTANGLE 20,30 or something like that and getting the results on a plotter. Then we moved on to graphical CAD packages, but lately, some have gone back to describing rather than drawing complex designs. Cornell University researchers are trying to provide the same options for coding. They’ve built a Juypter notebook extension called Notate that allows you to sketch and handwrite parts of programs that interact with traditional computer code. You can see a video about the work below.
https://techxplore.com/news/2022-11-tool-code.html
New programming tool turns sketches, handwriting into code
https://www.youtube.com/watch?v=Eynks13Gsfg
Tomi Engdahl says:
“Stop Writing Dead Programs” by Jack Rusher (Strange Loop 2022)
https://www.youtube.com/watch?v=8Ab3ArE8W3s
Tomi Engdahl says:
Kyle Wiggers / TechCrunch:
GitHub launches Copilot for Business, with corporate licensing and policy controls, for $19/user per month, and claims it won’t store or share companies’ code — GitHub Copilot, GitHub’s service that intelligently suggests lines of code, is now available in a plan for enterprises months …
https://techcrunch.com/2022/12/08/github-launches-copilot-for-business-plan-as-legal-questions-remain-unresolved/