They open-sourced it because they want it to be a standard

The fact that Pickle and .pkl are already the name and extension for a common existing file format is driving me insane.

13:17 "Imagine if your JSON autocompleted and gave you errors when you were editing it" You don't even have to imagine, it's already a thing with JSON Schema.

as a person who uses python pickle files every day i find this naming choice very annoying

You can tell they want folks to use it because they also released a neovim plugin and aren't just catering to VScode users

I used to Pickle my Python back in the day.

the smartest thing a new standard can do is make it easy to incrementally migrate, and it seems they are doing that

I love that the example password they used was "hunter2" lol

Someone's writing Doom in that

I work at apple, i joined when it wasn’t open source and i was very skeptical about PCL ( internal it’s called PCL instead of PKL) but it does solve a lot of problems and the IDE integration is great. It has completely replaced helm in our team, it’s much better. I hope eventually helm charts will also be published in PKL.

I feel bad for people that have to now use this and the pickle module for file saving in python programs

My first thought was it sounds just more complicated to use

Regex makes this all the more cursed. Now you can have a string format language inside of a data format language which can now be directly processed inside of your application's language, which means you have a language in a language in a language. I am absolutely digging this! 😂

I dont want logic in my config files, jesus christ I cant find this appealing at all.

Sooo... They didn't know Nix, Nickel, Dhall, CUE, Jsonnet or HCL existed and therefore had to create their own thing? :/ It doesn't even look that good tbh. But yeah, impressive that Apple open sources something. That doesn't happen very often.

It's basically the SCSS/SASS of config. Slick.

About the IDE autocompletion 13:30, you do have json-schema.

Cool idea, but I'm having a hard time understanding the actual use case. I have never found myself needing a language agnostic config, Both JSON and YAML have schema files which solves auto complete.

I would rather them put thos energy into fixing the crashing bug in Xcode. Or maybe decoupling that IDE and compiler from MacOS versions so you can work on old apps without having to switch to old Macs with old MacOS versions.

Pkl feels like Typescript meets SASS

Dude this isn't as big of a problem in JS land. For JSON, we have schemas. For JavaScript and TypeScript, most packages come with a defineConfig out of the box, and if they don't, rest assured somebody has already published an NPM package for that purpose.

chatter getting worked up about "version conflicts in config files": that's literally just a thing. The config format (or parts of it) may change over time after all, and it's important to keep track of that. It's great if Pkl can encode these existing problems and provide editor support for solving them... tho I wonder what form that'll take in practice, if and how different versions of a config format might be supported at the same time.

When I saw a configuration language that is "a blend between a static language and a general-purpose programming language" I immediately thought of Nix, a language with similar ideas created for a similar purpose. Nix doesn't seem to do very well outside Nix and NixOS ecosystems though, and Pkl does seem easier to grasp.

As a Typescript developer i don't see much value in this, because a pkl file have roughly the same lines of code of a regular js/ts file used for configuration, but using js/ts doesn't need to install additional binaries or dependencies. However i can see some potential for more complex languages like Go/Rust/Java/etc. that are not suited for small "scripts" since they take in account stuff that you don't care when creating a configuration file such as pointers, packages, namespaces, classes, the borrow checker, constructors, errors handling.

I'm afraid that someone is going to craft some overly complex config with this syntax, becoming hard to understand and edit by others

Honey, I shrunk the JSON!

reading an article while recording yourself is soooo creative, original and value adding....

There's another configuration language I like which is Dhall. For those who love Haskell, Rust and etc.

"Pickle" sounds like "Pickel" which is German for "Pimple". Can't wait to hear my coworkers say "Create a pimple file for this project!". For that reason, I'm out 😆

All the Python folks are hissing about this (don’t blame ‘em, they’ve been using “pickle” for serialization for ages). Anyway - I wonder if at Apple, all their Kubernetes cluster manifests are written in Pkl files. Hmm… that’d be interesting to look at!

Every year you present two vscode killers and three json replacements

How would you compare this to Cue? Seems like they are solving the same problems

I swear people undervalue the importance of ease of writing a parser. JSON was designed to be easy to parse; this obviously is not

I'm going to keep using JSON, avoid YAML, never use XML on principal and now avoid using Pkl. Sounds good!

Why they need validation in a config file? My program can read the file and tell the user what is wrong. I don't need to learn a new scripting language for that. And if you config file gets too big I want to use a real programming language to create it anyway. Plus source control.

Yes .properties are still being used especially in default spring boot apps

This is very very cursed, could not expect less from Apple

This concept has already been executed in the form of Dhall and Nickel. Nice to see another competitor, but I’ll stick with Dhall.

So they recreated DHALL?

I don't understand why this matters. If you need enforcement or validation at the configuration file level you catch it at processing or generation. This does the same thing while also being another middleware you have to configure and maintain. Saying that its hard to maintain some code that generates or validates your configuration or that any other languages isn't made for that is a silly thing to say.

Classes, functions, loops and annotations; surely they did not reinvent C# or Java?! So to prevent using, say, groovy to do this, we now need pkl. That's just replacing 💩 with new 💩. All this smells too much like XML with xml schema. But a bit better, because XML is a massive 💩🙃

Python’s pickle library: am I a joke to you?

They thankfully realised that the only way to have it adopted is to not only open source it but provide extensions to major editors, even VS Code. It's a good call, if they tried to make something proprietary, it would die painfully. Pkl seems cool, but it smells of something that will be infamous for quirks and hard to make parsers like YAML. Time will tell I guess, I do like it and hope it catches on and ends up being good.

honestly this seems REALLY cool - from the title I thought it was just another way of storing data that's nicer to use than json like hjson or yaml, but no this seems like WAY more!! really cool stuff :D

It seems they tried to recreate Terraform's HCL language, but without Terraform behind. Still I don't see it's usage overlapping wit json/yaml/toml or whatever. Let's see 3 use cases: 1. Transport format: it doesn't seem suitable (if I need schema oriented stuff and validation why not using binary formats such as thrift,avro or protobuffers?) 2. app configuration: imho I still would go for something simple and execute logic in my application instead of adding an additional step in my build process for compiling and packaging 3. Build configuration: do i really need standardization?eg If I'm in the jvm ecosystem I use gradle with groovy or kts and there is one in a billion cases where I need to transfer this configuration to another stack. Yes it takes more mental energy to learn all the tools and languages in order to be a polyglot developer but there is not so much to do unless you don't want to invent a an ecosystem agnostic deps/build management system...and good luck with that!

I can't wait to see this for Terraform

Am I the only one that thinks this would be creating more work and costing more time than it saves? It just seems awfully redundant. Maybe it's just because of the nature of what my projects usually are...

People who use Yaml are beyond saving…

So C macros for config files? something like Cmake? This is just another syntax to add to the collection I have to use once every few weeks. Between all these scripting languages, config formats, CLIs, programming languages, etc we are expected to know is nearing 100+.

Being a big fan of comptime in Zig, this will work beautifully. Types in more complex use cases are in desperate need of logic that can be resolved during the compilation of a particular program.

Theo this is exactly the approach Hashicorp tried to take with HCL

apple and open source in the same sentence is funny af

So, they created Cascading Configuration Language; they should have named it CCL. Given how maintainable the seemed-like-a-good-idea-at-the-time CSS turned out to be, I am not so sure that we should consider them creating a cascading configuration language to be a good thing... 🤷‍♂️ #jmtcw

1:26, Apple has an official Swift LSP for VSCode btw

So from my understanding, this is supposed to help checking out projects, where the default config is ommitted from the repository, but you still want a default config to be created on first run, like an ENV bootstrap ? Or what is this useful for ?

This is so awesome ! Currently I'm using json config file to validate and get autocomplete on my json files. And I do not have the best experience with it. Pkl could be a game changer !

Wouldn’t say say Apple dislike JavaScript when they have integrated JavaScript support all over the place in their products. But yeah, Pkl looks cool! Always great to see more safety in languages. Thanks for showcasing it.

spring boot integration 😲

ngl the most interesting part to me is standardizing the way runtime json gets generated 😮 it’s an easy task but cool not to have to decipher whatever madness someone cooks up to do it

00s - use xml 10s - use json and... xml. for legacy reason 20s - use yaml and json and xml.... yes, still 30s - pkl! now we have pkl, yaml, json and... xml. yes you WILL

I'm all in for built-in declarative validation rules, but built-in programming will make it hard to maintain readability (you don't know the result until the file is executed / compiled). Still will give it a go, though

If they keep extending it this way, they'll eventually end up with full blown JavaScript.

Apple reinventing Nix was unexpected to say the least.

Years ahead: > a hefty chonk of industry now indulges Pkl`es in The Pantry Papple: > Oy, dearest fellas, we've been compelled to announce changes to licensing. Products with 100+ users shall now be subject to billing plans for them Pkl`s and are required to allow full telemetry & analytics on all yo' devices... ee and y'all have to use Siri

So they essentially made protobuf for config files

Honestly, I've already seen all of this before. There's a language much smaller called Nickel, same concept but it's based on FP (perfect for config) and it's already past 1.0.0.

So it doesn't replace or "kill" anything, it just makes making those things more usable? I don't think I'm understanding it right

Turing complete in data format? Once again proving the only thing human learnt from history is that we learnt nothing from history.

A solution in search of a problem...that doesn't exist. We REALLY need to snap out of this mindset where everything needs to have a framework, transpiler, linter, build tool etc. JSON, YAML et al is super simple already. There is no need for introducing an intermediary format to "compile" it to JSON or YAML. It just ads complexity without any benefit. It's not like you can make one PKL config and then move it around between different applications, since those applications would have different config options and naming conventions.

Don't think kotlin support is mainly about android. Kotlin is used to build ios apps and apps across the Apple eco system. Also it's just a better java and it's able to interop with java so it seems like low hanging fruit though if it's true multi platform kotlin it'll be a bit more that java -> kotlin. Happy to see Go support as a first class supported language btw!

Let's make inefficient configs also confusing.

This looks very much like the next log4j vulnerability waiting to happen. I'm always surprised how simple things like logging or configuring can become so overengineered. Also validating configuration options in the config rather than at it's use site strikes me as similar to validating user-submitted data only on the browser side and not the server side... it just feels wrong.

I like how the guy from Super Troopers agrees with me that PKL is probably the path forward in terms of configuration languages. It encodes a lot of type information, so it follows that with PKL is at least capable to generating any static configuration that requires less information. On the other hand, the fact that it is limited as a programming language guarantees that it will remain focused and stay easy to read.

The fact Go is considered as the first 4, shows Go is going places🔥

I knew Silicon Valleys fondness of pickleball was going to spill over into the collective unconscious.

This is the kind of content I'd subscribe for. Have seen your videos ocassionally, but valuable content like this is subsbscription worthy.

Apple building a neovim plugin!? Charlie, the world is not the same as it was

Nope. This is the last thing the industry needs. Sensible consumers avoid their overpriced products, and they should also never touch an apple technology that tries to get into our workflow. "FOSS" or not. No more corporate closed source proprietary. Snap out of it people, development isn't fashion.

If Microsoft has thought us anything it’s that any company can go open source.

This came out of nowhere, they basically made a very accessible and powerful modelling language with generators and all... incredible

When i heard about pkl i was not interested thinking we already have enough tools, but the features shown here have some features. I can imagine using this to share a configuration between a frontend js and a backend rust/php/c application.

Tell me apple have not heard of JSON schemas without telling me apple have not heard of JSON schemas.

Oh god, another migration potential. Don't let my boss see this.

I am loving that theo has returned back to his roots in terms of tye content he is putting out.

It's far from JSON/YAML. Also we have HCL which kinda masks itself as something extra. I am very sceptical of this. Smells like Protobuf, why not use the damn Protobuf?

Nickel also have constraints and documentation. And Nix is really cool in merging things and have inter-dependent pluggable modules of configurations.

hunter2 as the example password is a funny reference

Gives me xkcd 927 vibes... "One standard to rule them all"

"Configuration is becoming too complex, we need a new programing languaje for configurations. " is something that you hear from a newly graduated programmer

I don’t like that it has the same name as pythons serialisation format.

I've been using Dhall for the last 5 or 6 years, I honestly think the only reason it hasn't caught on is it came from a functional programming background.

People have already lived to 120+. Setting a maximum age of 130 is surprisingly shortsighted.

do we get a PKL - SQL Table? oh wait, you're covering that right after I asked... damn

Just use JS. extend JSON with JS that’s the sane way to do it. I didn’t like this pkl thing at all.

Make the XCode vid. Every now and then I'm forced into it for some swift I have to deal with, and it's just the worst of the worst. So I think "NP, I'll just recode this app on Linux in a different language, and compile it on Mac." All is well until it comes time to sign the app with the Apple Dev key. Then, the nightmare begins anew.

adding ‘logic’ to config is like building a house of cards, except where the cards are made of s**t

Because we all want another programming language in our repository.

It should be noted and remembered that there is absolutely nothing special about any kind of data file, whether it be a real config file (globals and sections), an XML config file, a JSON file, a '90's database and multi table file like Dungeon Keeper has, or any other plain text data file that we can write. They all originally had programs that parsed them and used the data values how they needed. Like Dungeon Keeper using the multiple relatable text data tables, which I have made a Console editor for. I very recently made my own C# parser and writer for JSON data which works perfectly and is very strict on there being no errors in the text. So now I have a no-hassle way of using JSON data from a file. I could use it for app config and even game data which would allow the game to be modded. Yet long before that I made the same deal with XML, with better functionality in C#, and long before that I made the same deal with real config. I even once made a data reader that turns the first words into column names and all the next words into entry names and auto make a text table like the Dungeon Keeper ones, even with initial values. It is so easy to make custom ways to read data text files. You just need to make the app that parses the data into the runtime data, like objects etc., that it needs. This is all very fun stuff, but don't be sucked in with the hype. We can all do this.

Most known Apple's OSS projects are CUPS (printing system) and Webkit (browser engine). But it looks like they handed over the development of original CUPS to openprinting and now only focus on "Apple CUPS".

he turned JSON into a pkl, funniest config language I've ever seen