RSS feeds

02 Oct 2023blogs.perl.orgSingle Color Methods of GTC
01 Oct 2023Planet HaskellMagnus Therning: How I use Emacs
01 Oct 2023Planet HaskellMark Jason Dominus: The Irish logarithm
30 Sep 2023blogs.perl.orgPerl Weekly Challenge #236 - Lemonade Stand
30 Sep 2023Planet HaskellGil Mizrahi: Implementing kind inference
30 Sep 2023Planet HaskellMagnus Therning: Using Emacs as $EDITOR
30 Sep 2023Planet HaskellMatthew Sackman: Using rsync for backups
30 Sep 2023Standard C++CppCon 2023 Back to Basics: Algorithms -- Klaus Iglberger
29 Sep 2023Planet HaskellGHC Developer Blog: GHC 9.8.1-rc1 is now available
29 Sep 2023Standard C++CppCon 2023 Powered by AI: A Cambrian Explosion for C++ Software Development Tools -- Emery Berger
29 Sep 2023Standard C++CppCon 2023 The Story on the Misuse of Exceptions and How to Do Better -- Peter Muldoon
29 Sep 2023Standard C++CppCon 2023 A Fast, Compliant JSON Pull Parser for Writing Robust Applications -- Jonathan Müller
28 Sep 2023blogs.perl.orgplenv-libdirs
28 Sep 2023blogs.perl.orgThis Week in PSC (118)
28 Sep 2023Standard C++CppCon 2023 Building Effective Embedded Systems: Architectural Best Practices -- Gili Kamma
28 Sep 2023Standard C++Inside STL: The array -- Raymond Chen
28 Sep 2023Standard C++CppCon 2023 C++20 Modules: The Packaging and Binary Redistribution Story -- Luis Caro Campos
27 Sep 2023blogs.perl.orgHash of Arrays Deathmatch : Native Perl vs. DBM::Deep vs. Redis
27 Sep 2023blogs.perl.orgPerl Weekly Challenge 236: Exact Change
27 Sep 2023Standard C++CppCon 2023 Finding Your Codebases C++ Roots -- Katherine Rocha
27 Sep 2023Standard C++Meeting C++ 2023 - the last online conference?
26 Sep 2023blogs.perl.orgPerl Weekly Challenge 236: Array Loops
26 Sep 2023Standard C++CppCon 2023 Surveying the Community: What Could Possibly Go Wrong? -- Anastasia Kazakova
26 Sep 2023Standard C++C++20 Dynamic Allocations at Compile-time -- Andreas Fertig
25 Sep 2023blogs.perl.orgWriting Perl with Emacs: Are there perl-mode users around?
25 Sep 2023Planet HaskellGHC Developer Blog: GHC 9.6.3 is now available
25 Sep 2023Standard C++CppCon 2023 Back to Basics: Testing -- Phil Nash
25 Sep 2023Standard C++CppCon 2023 Finding a Purpose for Errors in Safety-Critical SYCL -- Erik Tomusk
24 Sep 2023Planet HaskellMagnus Therning: Defining a formatter for Cabal files
24 Sep 2023Standard C++CppCon 2023 Noexcept? Enabling Testing of Contract Checks -- Halpern/Doumler
23 Sep 2023blogs.perl.orgThis week in PSC (116)
23 Sep 2023blogs.perl.orgThis week in PSC (117)
23 Sep 2023blogs.perl.orgPerl Weekly Challenge #235 - Splicing and Dicing
23 Sep 2023Standard C++CppCon 2023 Undefined Behavior: What Every Programmer Should Know and Fear -- Fedor Pikus
23 Sep 2023Standard C++CppCon 2023 Building Consensus on a Set of Rules for Our Massive C++ Codebase -- Sherry Sontag
22 Sep 2023Standard C++CppCon 2023 Symbolic Calculus for High-performance Computing Using C++23 -- Vincent Reverdy
22 Sep 2023Standard C++Passkey Idiom: A Useful Empty Class -- Arne Mertz
22 Sep 2023Standard C++CppCon 2023 Problems and Solutions Using Coroutines In a Modern Codebase -- Francesco Zoffoli
21 Sep 2023Planet HaskellTweag I/O: Behind the scenes with FawltyDeps v0.13.0: Matching imports with dependencies
21 Sep 2023Standard C++CppCon 2023 Object Introspection: A Revolutionary Memory Profiler for C++ Objects -- Haslam/Sarwade
21 Sep 2023Standard C++Highlighting the program for Meeting C++ 2023
21 Sep 2023Standard C++CppCon 2023 How to Build and Deploy Your First C++ Automated Refactoring Tool -- Kristen Shaker
21 Sep 2023Standard C++CppCon 2023 Optimizing Robotics Algorithms With C++'s Compile-Time Features -- Stephen Brawner
20 Sep 2023blogs.perl.org Perl Weekly Challenge 235: Duplicate Zeros
20 Sep 2023Planet = erlang.Erlang/OTP 26.1 Release
20 Sep 2023Planet = erlang.Strong arrows: a new approach to gradual typing
20 Sep 2023Planet HaskellJoey Hess: Haskell webassembly in the browser
20 Sep 2023Standard C++CppCon 2023 A Case Study on Using std::future for Robot Drivers -- Anthony Baker
20 Sep 2023Standard C++CppCon 2023 Embracing CTAD -- Nina Ranns
20 Sep 2023Standard C++Inside STL: The deque, implementation -- Raymond Chen
20 Sep 2023Standard C++CppCon 2023 Is std::mdspan a Zero-overhead Abstraction? -- Oleksandr Bacherikov
20 Sep 2023Standard C++CppCon 2023 Coping With Other People's Code -- Laura Savino
19 Sep 2023Planet HaskellGHC Developer Blog: GHC 9.8.1-alpha4 is now available
19 Sep 2023Planet HaskellWell-Typed.Com: ZuriHac 2023 and GHC Contributors' Workshop: Summary and Materials
19 Sep 2023Planet HaskellGabriella Gonzalez: GHC plugin for HLint
19 Sep 2023Standard C++CppCon 2023 A Journey Into Non-Virtual Polymorphism -- Rudyard Merriam
19 Sep 2023Standard C++CppCon 2023 Applicative: The Forgotten Functional Pattern -- Ben Deane
19 Sep 2023Standard C++CppCon 2023 Exploration of Strongly-typed Units: A Case Study from Digital Audio -- Roth Michaels
18 Sep 2023blogs.perl.orgPerl Weekly Challenge 234: Unequal Triplets
18 Sep 2023blogs.perl.orgPerl Weekly Challenge 235: Remove One
18 Sep 2023Standard C++Inside STL: unordered_map, unordered_set, unordered_multimap, & unordered_multiset -- Raymond Chen
18 Sep 2023Standard C++CppCon 2023 Six Ways for Implementing Math Expressions Calculator -- Amir Kirsh
18 Sep 2023Standard C++CppCon 2023 Object Lifetime: From Start to Finish -- Thamara Andrade
17 Sep 2023Standard C++CppCon 2023 Lock-free Atomic Shared Pointers Without a Split Reference Count? -- Daniel Anderson
16 Sep 2023blogs.perl.orgOf Go, C, Perl and fastq file conversion Vol III : pledging allegiance to the flag
16 Sep 2023blogs.perl.orgOf Go, C, Perl and fastq file conversion Vol IV : gone in 60 seconds (or less)
16 Sep 2023Planet HaskellMagnus Therning: Setting up emacs-openai/chatgpt
16 Sep 2023Standard C++CppCon 2023 Back to Basics: Initialization -- Ben Saks
16 Sep 2023Standard C++CppCon 2023 Why Loops End -- Lisa Lippincott
15 Sep 2023blogs.perl.org Of Go, C, Perl and fastq file conversion Vol II : the Jedi regex
15 Sep 2023blogs.perl.orgCGI::Tiny & Dispatch::Fu - nearly a perfect match
15 Sep 2023Standard C++CppCon 2023 BehaviorTree.CPP: Task Planning for Robots and Virtual Agents -- Davide Faconti
15 Sep 2023Standard C++CppCon 2023 Taro: Task-graph-based Asynchronous Programming Using C++ Coroutines -- Dian-Lun Lin
15 Sep 2023Standard C++CppCon 2023 Getting Build Tools to Talk to Each Other: Lessons Learned -- Diego Rodriguez-Losada
14 Sep 2023blogs.perl.orgPerl Weekly Challenge #234 - Sharing is Caring
14 Sep 2023Standard C++CppCon 2023 Leveraging a Functional Approach for More Testable and Maintainable ROS 2 -- Bilal Gill
14 Sep 2023Standard C++Standard C++ Foundation Annual Report for Fiscal Year 2023
14 Sep 2023Standard C++CppCon 2023 std::linalg: Linear Algebra Coming to Standard C++ -- Mark Hoemmen
14 Sep 2023Standard C++Meeting C++ live with Kevlin Henney
14 Sep 2023Standard C++CppCon 2023 Visual Studio: Make Debugger, Diagnostics Improvements, Video Games, & More -- Li/Girmay
14 Sep 2023Standard C++CppCon 2023 More Ranges Please -- Roi Barkan
14 Sep 2023Standard C++Inside STL: The deque, design -- Raymond Chen
13 Sep 2023blogs.perl.orgGet more from you constants with constant::more
13 Sep 2023Planet HaskellWell-Typed.Com: The Haskell Unfolder Episode 11: Haskell at ICFP
13 Sep 2023Planet HaskellMark Jason Dominus: Horizontal and vertical complexity
13 Sep 2023Standard C++CppCon 2023 "Distributed Ranges": A Model for Building Distributed Data ... -- Benjamin Brock
13 Sep 2023Standard C++CppCon 2023 Back to Basics: Iterators -- Nicolai Josuttis
13 Sep 2023Standard C++CppCon 2023 The Au Library: Handling Physical Units Safely, Quickly, and Broadly -- Chip Hogg
12 Sep 2023blogs.perl.orgThis week in PSC (113)
12 Sep 2023blogs.perl.orgThis week in PSC (114)
12 Sep 2023blogs.perl.orgOf Go, C, Perl and fastq file conversion Vol I : intro
12 Sep 2023blogs.perl.orgThis week in PSC (115)
12 Sep 2023Planet HaskellChris Reade: Graphs, Kites and Darts – and Theorems
11 Sep 2023blogs.perl.orgPerl Weekly Challenge 233: Frequency Sort
11 Sep 2023blogs.perl.orgPerl Weekly Challenge 234: Common Characters
10 Sep 2023blogs.perl.orgAnnouncing Dancer Core Team Changes
10 Sep 2023Planet HaskellMichael Snoyman: Owned values and Futures in Rust
10 Sep 2023Planet HaskellMagnus Therning: Using emacs for the scrollback in terminal multiplexers
10 Sep 2023Planet HaskellMark Jason Dominus: The Killer Whale Dagger
09 Sep 2023blogs.perl.orgA bit of history about The Gecko Book, aka "Learning Perl on Win32 Systems"... (from my "Half my life with Perl" talk a decade ago)
09 Sep 2023Planet HaskellMark Jason Dominus: My favorite luxurious office equipment is low-tech
08 Sep 2023blogs.perl.orgPerl Weekly Challenge 233: Separate Digits
06 Sep 2023blogs.perl.orgPerl Weekly Challenge #233 - Similar Words and Frequency Sort
06 Sep 2023Planet HaskellMark Jason Dominus: Why Git needs a better UI
05 Sep 2023blogs.perl.orgGTC API (how to design a rich interface)
05 Sep 2023Planet HaskellLysxia's blog: Abstract nonsense
03 Sep 2023Planet HaskellGabriella Gonzalez: Applicatives should usually implement Semigroup and Monoid
02 Sep 2023blogs.perl.orgI just discovered Dev.to
02 Sep 2023Planet HaskellSandy Maguire: Certainty by Construction Progress Report 9
01 Sep 2023blogs.perl.orgIdle Thoughts on Old Perl Versions for New Distributions
01 Sep 2023Planet HaskellWell-Typed.Com: Well Typed collaborates with the Haskell Community to support HLS development
30 Aug 2023Planet HaskellOleg Grenrus: Using cabal-install's dependency solver as a SAT solver!?
30 Aug 2023Planet HaskellWell-Typed.Com: The Haskell Unfolder Episode 10: generalBracket
29 Aug 2023Planet = erlang.An Introduction to RabbitMQ | Erlang Solutions
28 Aug 2023blogs.perl.orgThe Hidden Power of Prototypes
28 Aug 2023blogs.perl.orgOutdated perl utility txt2html migration
28 Aug 2023Newest Python PEPsPEP 727: Documentation Metadata in Typing
28 Aug 2023Planet HaskellMichael Snoyman: Type Safety Doesn't Matter
25 Aug 2023Planet HaskellGHC Developer Blog: GHC 9.4.7 is now available
24 Aug 2023Newest Python PEPsPEP 726: Module ``__setattr__`` and ``__delattr__``
23 Aug 2023Planet HaskellGHC Developer Blog: GHC 9.8.1-alpha3 is now available
23 Aug 2023Planet HaskellSandy Maguire: Certainty by Construction Progress Report 8
22 Aug 2023The OCaml PlanetBuilding the OCaml GPT library
22 Aug 2023Planet HaskellBrent Yorgey: Swarm 0.4 release
21 Aug 2023Planet HaskellDan Piponi (sigfpe): What does it mean for a monad to be strong?
18 Aug 2023Planet HaskellWell-Typed.Com: Reducing Haddock's Memory Usage
17 Aug 2023The OCaml PlanetYour Programming Language and its Impact on the Cybersecurity of Your Application
17 Aug 2023Newest Python PEPsPEP 725: Specifying external dependencies in pyproject.toml
16 Aug 2023Planet HaskellPhilip Wadler: Orwell was right
15 Aug 2023The OCaml PlanetOCaml Weekly News, 15 Aug 2023
15 Aug 2023The OCaml PlanetA Poet's Guide to Product Management with Peter Bogart-Johnson
12 Aug 2023The OCaml PlanetOn indefinite truth values
12 Aug 2023Planet HaskellSandy Maguire: Certainty by Construction Progress Report 7
10 Aug 2023The OCaml PlanetKcas: Building a Lock-Free STM for OCaml (2/2)
10 Aug 2023Planet HaskellMatt Parsons: The Meaning of Monad in MonadTrans
10 Aug 2023Planet HaskellTweag I/O: Supercharging your Rust static executables with mimalloc
08 Aug 2023The OCaml PlanetOCaml Weekly News, 08 Aug 2023
07 Aug 2023The OCaml PlanetKcas: Building a lock-free STM for OCaml (1/2)
07 Aug 2023Planet HaskellPhilip Wadler: Will A.I. become the new McKinsey?
07 Aug 2023Planet HaskellPhilip Wadler: The Problem with Counterfeit People
04 Aug 2023The OCaml PlanetOutreachy Mid-Point Progress
04 Aug 2023Newest Python PEPsPEP 723: Embedding pyproject.toml in single-file scripts
02 Aug 2023The OCaml PlanetOBuilder on macOS
01 Aug 2023The OCaml PlanetOCaml Weekly News, 01 Aug 2023
31 Jul 2023The OCaml PlanetOCaml in Space - Welcome SpaceOS!
31 Jul 2023Planet HaskellMatt Parsons: Yamaha vs NS Design Electric Cellos
31 Jul 2023Planet HaskellChris Reade: Diagrams for Penrose Tiles
31 Jul 2023Planet HaskellPhilip Wadler: Our Labor Built AI
30 Jul 2023Planet HaskellChris Reade: Graphs, Kites and Darts – Empires and SuperForce
30 Jul 2023Planet HaskellChris Reade: Graphs, Kites and Darts
29 Jul 2023Planet = erlang.What Should FinTech Learn From Telecom? Portfolio Conference, Banking Technology 2021
28 Jul 2023Newest Python PEPsPEP 724: Stricter Type Guards
27 Jul 2023The OCaml PlanetReflections on the MirageOS Retreat in Morocco
27 Jul 2023The OCaml PlanetVariations on Weihrauch degrees (CiE 2023)
27 Jul 2023Planet HaskellTweag I/O: Building a Rust workspace with Bazel
25 Jul 2023The OCaml PlanetOCaml Weekly News, 25 Jul 2023
23 Jul 2023Planet = erlang.Erlang Solutions Live Stream
22 Jul 2023Planet HaskellJasper Van der Jeugt: Lazy Layout
20 Jul 2023The OCaml PlanetCreating a UDP server and client in OCaml
20 Jul 2023The OCaml PlanetSetting up Opam and MirageOS on MacOS Ventura, on Apple Silicon
20 Jul 2023Planet HaskellTweag I/O: How to Prevent GHC from Inferring Types with Undesirable Constraints
19 Jul 2023The OCaml PlanetSandmark: Boosting Multicore Projects with Performance Benchmarking
19 Jul 2023Newest Python PEPsPEP 722: Dependency specification for single-file scripts
18 Jul 2023The OCaml PlanetRelease of Frama-C 27.1 (Cobalt)
18 Jul 2023The OCaml PlanetOCaml Weekly News, 18 Jul 2023
18 Jul 2023The OCaml PlanetContinuity principles and the KLST theorem
17 Jul 2023Planet HaskellPhilip Wadler: Gradual Effect Handlers
14 Jul 2023Planet = erlang.Language Design: When Less is More
14 Jul 2023Planet HaskellSandy Maguire: Certainty by Construction Progress Report 6
13 Jul 2023Planet HaskellTweag I/O: Python Monorepo: an Example. Part 2: A Simple CI
13 Jul 2023Planet HaskellBrent Yorgey: Compiling to Intrinsically Typed Combinators
12 Jul 2023The OCaml PlanetOCaml-CI Renovated
12 Jul 2023Newest Python PEPsPEP 721: Using tarfile.data_filter for source distribution extraction
11 Jul 2023The OCaml PlanetOCaml Weekly News, 11 Jul 2023
11 Jul 2023Planet HaskellChris Smith 2: Approval and Score Voting are Intrinsically Tactical
10 Jul 2023Planet HaskellChris Smith 2: Simulating Elections with Spatial Voter Models
09 Jul 2023Planet HaskellOleg Grenrus: Infix operator for pair type and term
08 Jul 2023Planet HaskellGil Mizrahi: Why I like JavaScript as a compilation target
07 Jul 2023The OCaml PlanetMaking OCaml 5 Succeed for Developers and Organisations
06 Jul 2023The OCaml PlanetWe're sponsoring SoME3
06 Jul 2023Planet HaskellIOHK Haskell: Wadler follows the giants of science
05 Jul 2023The OCaml PlanetZero-Day Attacks: What Are They, and Can a Language Like OCaml Protect You?
05 Jul 2023The OCaml PlanetFlorian's OCaml compiler weekly, 5 July 2023
04 Jul 2023The OCaml PlanetOCaml Weekly News, 04 Jul 2023
01 Jul 2023Newest Python PEPsPEP 720: Cross-compiling Python packages
01 Jul 2023Planet HaskellGil Mizrahi: Why I use the Twain web framework
29 Jun 2023The OCaml PlanetEmelleTV: Talking with Louis Roché about OCaml and Ahrefs
27 Jun 2023The OCaml PlanetOCaml Weekly News, 27 Jun 2023
25 Jun 2023Planet HaskellStackage Blog: LTS 21 release for ghc-9.4 and Nightly now on ghc-9.6
23 Jun 2023Newest Python PEPsPEP 718: Subscriptable functions
22 Jun 2023Planet = erlang.Type system updates: moving from research into development
21 Jun 2023The OCaml PlanetOxidizing OCaml: Rust-Style Ownership
20 Jun 2023The OCaml PlanetOCaml Receives the ACM SIGPLAN Programming Languages Software Award
20 Jun 2023The OCaml PlanetFlorian's OCaml compiler weekly, 20 June 2023
20 Jun 2023The OCaml PlanetOCaml Weekly News, 20 Jun 2023
20 Jun 2023Planet = erlang.Embrace Complexity; Tighten Your Feedback Loops
19 Jun 2023Planet = erlang.Elixir v1.15 released
15 Jun 2023The OCaml PlanetRelease of Frama-C 27.0 (Cobalt)
14 Jun 2023The OCaml PlanetIsomorphism invariance and isomorphism reflection in type theory (TYPES 2023)
13 Jun 2023The OCaml PlanetOutreachy Blog #1: Introduce Yourself
13 Jun 2023The OCaml PlanetFirst week experience at Outreachy
13 Jun 2023The OCaml PlanetOCaml Weekly News, 13 Jun 2023
12 Jun 2023The OCaml PlanetFlorian's OCaml compiler weekly, 12 June 2023
11 Jun 2023The OCaml PlanetAnti-personnel computing
06 Jun 2023The OCaml PlanetOCaml Weekly News, 06 Jun 2023
06 Jun 2023Newest Python PEPsPEP 715: Disabling bdist_egg distribution uploads on PyPI
05 Jun 2023The OCaml PlanetFlorian's OCaml compiler weekly, 5 June 2023
31 May 2023The OCaml PlanetSecurity in opam's cache handling (before 2.1.5)
30 May 2023The OCaml PlanetTwo variants of the Bind rule
30 May 2023The OCaml PlanetOCaml Weekly News, 30 May 2023
26 May 2023The OCaml PlanetOxidizing OCaml: Locality
23 May 2023The OCaml PlanetOCaml Weekly News, 23 May 2023
23 May 2023The OCaml PlanetFor those who just don’t Git it
18 May 2023The OCaml PlanetThe Future of Programming with Richard Eisenberg
16 May 2023The OCaml PlanetBeta release of Frama-C 27.0~beta (Cobalt)
16 May 2023The OCaml PlanetElegance in OCaml with TJ DeVries
16 May 2023The OCaml PlanetOCaml Weekly News, 16 May 2023
16 May 2023Planet = erlang.Erlang/OTP 26.0 Release
12 May 2023The OCaml PlanetSpecifying Functions: Two Styles
09 May 2023The OCaml PlanetOCaml Weekly News, 09 May 2023
05 May 2023The OCaml PlanetOptimising Archive Node Storage for Tezos
03 May 2023The OCaml PlanetAhrefs is now built with Melange
02 May 2023The OCaml PlanetOCaml Weekly News, 02 May 2023
28 Apr 2023The OCaml PlanetOCaml at MinidebConf TN 2023
28 Apr 2023The OCaml PlanetCyberhackathon Frama-C + Binsec
28 Apr 2023The OCaml PlanetFlorian's OCaml compiler weekly, 28 April 2023
26 Apr 2023The OCaml PlanetLambda Capabilities
25 Apr 2023The OCaml PlanetOCaml Weekly News, 25 Apr 2023
24 Apr 2023The OCaml PlanetFlorian's OCaml compiler weekly, 24 April 2023
18 Apr 2023The OCaml PlanetOCaml Weekly News, 18 Apr 2023
17 Apr 2023The OCaml PlanetFlorian's OCaml compiler weekly, 17 April 2023
14 Apr 2023The OCaml PlanetBuilding reproducible Python environments with XARs
11 Apr 2023The OCaml PlanetFlorian's OCaml compiler weekly, 11 April 2023
11 Apr 2023The OCaml PlanetOCaml Weekly News, 11 Apr 2023
06 Apr 2023The OCaml PlanetBuild faster with Buck2: Our open source build system
05 Apr 2023The OCaml PlanetServer-side rendering React in OCaml
04 Apr 2023The OCaml PlanetOCaml Weekly News, 04 Apr 2023
03 Apr 2023The OCaml PlanetOCaml compiler weekly, 3 April 2023
28 Mar 2023The OCaml PlanetOCaml Weekly News, 28 Mar 2023
27 Mar 2023The OCaml PlanetOCaml compiler weekly, 27 March 2023
22 Mar 2023The OCaml PlanetCompiler Hacking in Cambridge is Back!
21 Mar 2023The OCaml PlanetOCaml Weekly News, 21 Mar 2023
17 Mar 2023The OCaml PlanetCausally talking with @Dinoosaure about Mirage OS 4.0
17 Mar 2023The OCaml PlanetCasually talking about ReScript, OSS, and communities with Patrick Ecker
17 Mar 2023The OCaml PlanetTalking with Jaap Frolich about graphql-ppx
17 Mar 2023The OCaml PlanetTalking with Oscar Spencer about Grain Lang, WASM, PLT and ML
17 Mar 2023The OCaml PlanetCasually talking with Hongbo Zhang
17 Mar 2023The OCaml PlanetCasually talking with Eduardo Rafael about OCaml, Tezos and probably compilers
17 Mar 2023The OCaml PlanetTalking with Anil Madhavapeddy about OCaml, Tezos and @TrustedCarbon
17 Mar 2023The OCaml PlanetCausally talking with Sean Grove about GraphQL, OneGraph and ReasonML
17 Mar 2023The OCaml PlanetCasually talking with Gabriel Radanne about OCaml, meta-programming and much more
17 Mar 2023The OCaml PlanetCasually talking with Craig Ferguson about OCaml, Mirage, Irmin and more
17 Mar 2023The OCaml PlanetTalking with António Monteiro about Melange, Esy, Reason, OCaml and more
17 Mar 2023The OCaml PlanetTalking with Gabriel Nordeborn ReScript, Relay and everything else!
09 Mar 2023Read Rust - AllThe Registers of Rust
08 Mar 2023The OCaml PlanetMore Than a Day: How Does Tarides Promote Women in Tech?
02 Mar 2023The OCaml PlanetThe Journey to OCaml Multicore: Bringing Big Ideas to Life
28 Feb 2023The OCaml PlanetFixed Term (3 years) Engineer Position at CEA LIST - LSL
28 Feb 2023The OCaml PlanetFixed Term (3 years) Computer Scientist Position at CEA LIST - LSL
28 Feb 2023The OCaml Planet3-year Engineer Position at CEA LIST - LSL
28 Feb 2023The OCaml Planet3-year Computer Scientist Position at CEA LIST - LSL
28 Feb 2023Read Rust - AllReducing code size in librsvg by removing an unnecessary generic struct
24 Feb 2023Read Rust - AllKeyword Generics Progress Report: February 2023
17 Feb 2023Read Rust - AllWhy is building a UI in Rust so hard?
15 Feb 2023The OCaml PlanetRelease of Frama-C 26.1 (Iron)
14 Feb 2023Read Rust - AllParsing TFTP in Rust
14 Feb 2023Read Rust - AllRust to WebAssembly the hard way
14 Feb 2023Read Rust - AllNew release
13 Feb 2023The OCaml PlanetFormalizing invisible mathematics
10 Feb 2023The OCaml PlanetExploring strange new worlds of mathematics
09 Feb 2023Read Rust - AllDramatically reducing AccessKit’s memory usage
08 Feb 2023Read Rust - AllRustler - Using Rust crates in Elixir
08 Feb 2023Read Rust - AllTauri vs Iced vs egui: Rust GUI framework performance comparison
08 Feb 2023Read Rust - AllThe Git source code audit, viewed as a Rust programmer
07 Feb 2023Read Rust - AllSpeeding up Rust semver-checking by over 2000x
06 Feb 2023Read Rust - AllExploring Rust for Vulkan drivers, part 1
06 Feb 2023Read Rust - AllGenerate gem skeleton with Rust extension
29 Jan 2023Read Rust - AllThe size of Rust Futures
19 Jan 2023Read Rust - AllTesting SIMD instructions on ARM with Rust on Android
13 Jan 2023Read Rust - AllRunning Zola on WebAssembly
12 Jan 2023The OCaml PlanetLambda Retreat Report
12 Jan 2023Read Rust - AllSupporting the Use of Rust in the Chromium Project
11 Jan 2023Read Rust - Allgccrs in 2022
10 Jan 2023The OCaml PlanetEngineer Spotlight: Sudha Parimala
09 Jan 2023The OCaml PlanetWhat if writing tests was a joyful experience?
07 Jan 2023Read Rust - AllIs coding in Rust as bad as in C++?
07 Jan 2023Read Rust - AllWhat Every Rust Developer Should Know About Macro Support in IDEs
05 Jan 2023The OCaml PlanetEngineer Spotlight: Zach Shipko
31 Dec 2022The OCaml PlanetLearning OCaml in 2023
29 Dec 2022The OCaml PlanetEngineer Spotlight: Jules Aguillon
27 Dec 2022The OCaml PlanetLove Rust? Then OCaml's New Eio Library is for You
22 Dec 2022The OCaml PlanetOCaml 5 Multicore Testing Tools
22 Dec 2022Read Rust - AllAnnouncing KataOS and Sparrow
21 Dec 2022The OCaml PlanetAdvanced Merlin Features: Destruct and Construct
21 Dec 2022Read Rust - AllTen Years of Ru...ewriting my website
21 Dec 2022Read Rust - AllRust 2023
20 Dec 2022The OCaml PlanetHow Nomadic Labs Used Multicore Processing to Create a Faster Blockchain
19 Dec 2022The OCaml PlanetOCaml 5 With Multicore Support Is Here!
14 Dec 2022The OCaml PlanetHillingar: MirageOS Unikernels on NixOS
09 Dec 2022The OCaml PlanetMetAcsl for Frama-C 26.0 Iron
09 Dec 2022Read Rust - AllBuilding a Rust-y Vim clutch with the Raspberry Pi 2040
07 Dec 2022The OCaml PlanetOCaml 5 Release Candidate Now Available!
07 Dec 2022The OCaml PlanetMirageOS security advisory 03: xen with solo5 >= 0.6.6 & < 0.7.5
07 Dec 2022The OCaml PlanetAccelerating zk-SNARKs - MSM and NTT algorithms on FPGAs with Hardcaml
07 Dec 2022Read Rust - AllHelix Release 22.12 Highlights
07 Dec 2022Read Rust - AllThis Month in Rust OSDev: November 2022
06 Dec 2022Read Rust - AllLaunching the 2022 State of Rust Survey
06 Dec 2022Read Rust - AllKernelCI now testing Linux Rust code
01 Dec 2022Read Rust - AllMemory Safe Languages in Android 13
30 Nov 2022Read Rust - AllHow much does Rust's bounds checking actually cost?
30 Nov 2022Read Rust - AllFedora 38 Looks To Shift RPM To Sequoia, A Rust-Based OpenPGP Parser
30 Nov 2022Read Rust - AllOut-of-bounds memory access bug
29 Nov 2022The OCaml PlanetOCaml 5 Beta2 Release
25 Nov 2022Read Rust - AllSafely writing code that isn't thread-safe
24 Nov 2022The OCaml PlanetSolve the 2022 Advent of Code Puzzles with OCaml
24 Nov 2022Read Rust - AllRedox OS 0.8.0
24 Nov 2022Read Rust - AllRust developers can now generate consistent type schema with Typeshare
23 Nov 2022The OCaml PlanetVisualizing information propagation in markets
23 Nov 2022The OCaml PlanetRelease of Frama-C 26.0 (Iron)
22 Nov 2022The OCaml PlanetSix Surprising Reasons the OCaml Programming Language is Good for Business
22 Nov 2022Read Rust - AllFrom AST to bytecode execution in EndBASIC
22 Nov 2022Read Rust - AllThe carcinization of Go programs
22 Nov 2022Read Rust - AllFlux: Refinement Types for Rust
17 Nov 2022The OCaml PlanetComputations that differentiate, debug, and document themselves
17 Nov 2022The OCaml PlanetDeploying reproducible unikernels with albatross
16 Nov 2022The OCaml PlanetOCaml 5 at Open Source India 2022
15 Nov 2022The OCaml PlanetPresenting on Algebraic Effects at FP-SYD
10 Nov 2022The OCaml PlanetTowards Minimal Disk-Usage for Tezos Bakers
07 Nov 2022The OCaml PlanetMirageOS retreat in October
04 Nov 2022The OCaml PlanetInternship Position at CEA LIST - LSL
31 Oct 2022The OCaml PlanetHow to get started with OCaml in 2022
31 Oct 2022Read Rust - AllA first look at Rust in the 6.1 kernel
29 Oct 2022Read Rust - AllGeneric associated types to be stable in Rust 1.65
28 Oct 2022The OCaml PlanetThe MirageOS Retreat: A Journey of Food, Cats, and Unikernels
28 Oct 2022The OCaml PlanetBeta release of Frama-C 26.0~beta (Iron)
25 Oct 2022Read Rust - AllEvaluating Build Scripts in the IntelliJ Rust Plugin
21 Oct 2022Read Rust - AllRAII: Compile-Time Memory Management in C++ and Rust
21 Oct 2022Read Rust - AllA deeper look into the GCC Rust front-end
21 Oct 2022Read Rust - AllRust on Espressif chips - 17-10-2022
21 Oct 2022Read Rust - AllProgress report on rustc_codegen_cranelift (Okt 2022)
20 Oct 2022The OCaml PlanetUp-to-Date Online Documentation
19 Oct 2022The OCaml PlanetPorting Charrua-Unix and Rawlink to Eio
19 Oct 2022Read Rust - AllWelcoming Sage Griffin: Rust Foundation Communities Advocate
18 Oct 2022The OCaml PlanetOCaml's Platform Installer Alpha Release
17 Oct 2022The OCaml PlanetOCaml 5 Beta Release
15 Oct 2022Read Rust - Allretrowin32, a win32 emulator
14 Oct 2022The OCaml PlanetReal World OCaml Book Giveaway!
14 Oct 2022Read Rust - AllA Memory Safe Implementation of the Network Time Protocol
12 Oct 2022The OCaml Planet8 OCaml Libraries to Make Your Life Easier
11 Oct 2022The OCaml PlanetHappy birthday, Dana!
10 Oct 2022The OCaml PlanetICFP 2022 Review
06 Oct 2022The OCaml PlanetRelease of Frama-Clang 0.0.13
06 Oct 2022Read Rust - AllSingle Pass Recursion in Rust
06 Oct 2022Read Rust - AllAn Invitation to Rust Maintainers
06 Oct 2022Read Rust - AllHard Mode Rust
05 Oct 2022Read Rust - Allzerocal - A Serverless Calendar App in Rust Running on shuttle.rs
04 Oct 2022Read Rust - AllRewriting the Modern Web in Rust
04 Oct 2022Read Rust - AllHow (and why) nextest uses tokio, part 1
04 Oct 2022Read Rust - AllImplementing truly safe semaphores in rust, and the costs we pay for safety
29 Sep 2022The OCaml PlanetMirroring the opam repository and all tarballs
29 Sep 2022Read Rust - AllThe perils of pinning
29 Sep 2022Read Rust - AllFutures Concurrency IV: Join Ergonomics
29 Sep 2022Read Rust - Allcargo careful: run your Rust code with extra careful debug checking
29 Sep 2022Read Rust - AllAnnouncing the Rust Style Team
29 Sep 2022Read Rust - AllAnnouncing ICU4X 1.0
23 Sep 2022Read Rust - AllCompiling Rust with GCC: an update
23 Sep 2022Read Rust - AllA pair of Rust kernel modules
30 Sep 2021Read Rust - AllRust for the Polyglot Programmer
04 Aug 2021Read Rust - AllAdding Rust-Stable libstd Support for Xous
03 Aug 2021Read Rust - AllThe push for GATs stabilization
03 Aug 2021Read Rust - AllImprovements for #[doc] attributes in Rust
21 Jul 2021Read Rust - AllRust 2021 public testing period
06 Apr 2021Read Rust - AllRust in the Android platform
18 Mar 2021Read Rust - AllBuilding a shared vision for Async Rust
25 Feb 2021Read Rust - AllFerrocene Part 3: The Road
28 Jan 2021Read Rust - AllRust & the case of the disappearing stack frames
21 Jan 2021Read Rust - AllRustdoc performance improvements
21 Jan 2021Read Rust - AllRust in Production: 1Password
01 Jan 2021Read Rust - AllAnnouncing Rust 1.49.0
16 Dec 2020Read Rust - AllSequoia PGP v1.0 Released: The Seedling's a Sapling
14 Dec 2020Read Rust - AllLaunching the Lock Poisoning Survey
09 Dec 2020Read Rust - AllAnnouncing Minus, a cross-platform pager
27 Nov 2020Read Rust - AllAnnouncing Rustup 1.23.0
27 Nov 2020Read Rust - Alllib-ruby-parser: A Ruby Parser Written in Rust
24 Nov 2020Read Rust - AllWhat the Error Handling Project Group is Working On
19 Nov 2020Read Rust - AllAnnouncing Rust 1.48.0
11 Nov 2020Read Rust - AllExploring PGO for the Rust compiler
04 Nov 2020Read Rust - AllIntroducing Scipio - a Thread-per-Core Crate for Rust & Linux
21 Oct 2020Read Rust - AllNon-Generic Inner Functions
12 Oct 2020Read Rust - AllRust after the honeymoon
09 Oct 2020Read Rust - AllRust in curl with Hyper
08 Oct 2020Read Rust - AllAnnouncing Rust 1.47.0
07 Oct 2020Read Rust - AllRust + Raspberry Pi Tide Clock
30 Sep 2020Read Rust - AllAnnouncing the Portable SIMD Project Group
22 Sep 2020Read Rust - AllAsync Iteration Semantics
22 Sep 2020Read Rust - AllPorting EBU R128 audio loudness analysis from C to Rust
21 Sep 2020Read Rust - AllThrow Away Code
21 Sep 2020Read Rust - AllLow-Level Academy
21 Sep 2020Read Rust - AllCall for 2021 Roadmap Blogs Ending Soon
21 Sep 2020Read Rust - AllRust 2021 – Ethical Development
19 Sep 2020Read Rust - AllRust 2021: Make it accessible
19 Sep 2020Read Rust - AllTL;DR Rust
14 Sep 2020Read Rust - AllAnnouncing Actix Web v3.0
14 Sep 2020Read Rust - AllIntroducing auditable: audit Rust binaries for known bugs or vulnerabilities in production