Full Width [alt+shift+f] Shortcuts [alt+shift+k]
Sign Up [alt+shift+s] Log In [alt+shift+l]
85
We’re proud to announce that elementary OS 8 is available to download later today and shipping on several high-quality computers! With OS 8, we’ve focused in on: Creating a new Secure Session that ensures applications respect your privacy and require your consent A brand new Dock with productive multitasking and window management features Empowering our diverse community through Inclusive Design To get elementary OS 8, head to elementary.io later today for the download—or read on for an overview of what’s new. Privacy, Security & Consent Over the past several years we’ve been building features to improve the trust relationship with your computer by requiring your explicit informed consent and disallowing untrustworthy behavior on a technical level. We’ve done that by embracing Flatpak as the way to install apps on elementary OS and Portals for confining them to a safer sandbox. Now we’re extending that story with both new settings to put you in control of the system features apps can...
4 months ago

Improve your reading experience

Logged in users get linked directly to articles resulting in a better reading experience. Please login for free, it takes less than 1 minute.

More from elementary Blog

elementary OS 8.0.1 Available Now

It’s been a little over 100 days since elementary OS 8 was released, and we’re proud to announce another round of updates, including a fresh new download. We’ve been hard at work this winter addressing issues that you reported and we’ve added a couple new creature comforts along the way. This bug fix release also includes the latest Ubuntu LTS Hardware Enablement Kernel, so it’s worth checking out if you downloaded OS 8.0 and it disagreed with your hardware. AppCenter We now properly use dark mode brand colors and dark mode screenshots thanks to Italo. Plus, when developers provide screenshots for multiple desktop environments, we now prefer the ones intended for our desktop environment, Pantheon. We support the new <Developer> Appstream tag, thanks to Juan. And we now support the contribute URL type. AppCenter now shows dark mode screenshots when available Italo also fixed some issues with release notes overflowing out of their container, and we slightly redesigned the release notes window in the Updates page. He also addressed a few other issues in the Updates page that could occur while things were being updated or refreshed and made sure AppCenter recovers gracefully when its cache is emptied. Release notes dialogs have been slightly redesigned Search is also much faster thanks to Leonhard. And for developers, Ryo fixed loading your local metadata for testing with the --load-local terminal option. Files & Terminal Jeremy fixed another half-dozen reported issues in Files, including an issue that prevented entering file paths in search mode, an issue that prevented scrolling after deleting files, and an issue where files would disappear when dropped on an unmounted drive. The New file submenu now respects the hierarchy of folders in Templates. We now also respect the admin:// uri protocol for opening a path as an administrator, and Files is now styled correctly when run as administrator. He also fixed an issue where Terminal tabs took multiple clicks to focus, and an issue where keyboard shortcuts stopped working for tabs that had been dragged into their own new window. Plus, file paths and names are also now properly quoted when drag-and-dropped from Files into Terminal. System Settings System Settings now allows configuring its notifications in System Settings → Notications. So you can turn off bubbles if you don’t want to receive notifications about updates, for example. We’ll also no longer automatically download updates when on metered connections and send a notification instead, thanks to Leonhard. Plus we no longer check for updates in Demo Mode. Updates now show their download size and you can see progress towards our monthly sponsorship goal In System, Vishal made sure we show how large an update will be before downloading it and that we skip held-back packages—such as phased or staged updates—when preparing the updates bundle so that it will more reliably succeed. Alain added a progress bar while downloading. And Ryo made sure the last refresh time is more accurate when no updates are available. Alain also added a new progress bar that represents how close we are to meeting our monthly sponsorship goal. In Applications, you can now disallow notifications access. This is especially useful for apps which use the notifications portal, but don’t properly report their notification usage and can’t be controlled in the Notifications settings page. Reign in apps that don’t appear in Notifications settings In Network there are two new settings: whether a network should be automatically connected to when available and whether to reduce background data usage when connected to that network. Disable autoconnect or mark a network as metered We also updated the pointer icons in Mouse & Touchpad settings and the checkmarks in Locale settings will now respect your chosen accent color. Plus settings pages with sidebars now remember the width you adjusted them to, thanks to Alain. Installation & Onboarding David fixed a crash with certain partitioning schemes in the Installer’s custom install view. And the Encryption step was redesigned to fit on a single page, solving an issue with confusing navigation. Plus, onboarding will now always stay centered on the screen, even when resized. Panel & Quick Settings Ilya fixed an issue with the panel height when using the Classic session and HiDPI displays. The app context menu in the Applications menu now shows a “Keep in Dock” checkbox, just like in the Dock thanks to Stella. In the Power menu, we now show the device model if available, and avoid erroneously showing an empty battery icon thanks to Alain. In the Sound menu, Dmitry fixed loading album art from certain apps like Google Chrome, and we fixed an issue where player icons could become too large. See who else is logged in and quickly switch accounts from Quick Settings In Quick settings, Leonhard fixed an issue with performing updates while shutting down. And Alain added a new page where you can see which other people are logged in and quickly switch between accounts. Dock Leo added a bit more spacing between launchers and their running indicators, and fixed an issue where larger icons could be clipped at the peak of their bounce animation. Apps who don’t notify on startup will no longer bounce in the dock indefinitely, thanks to Leonhard. We fixed an issue where the dock would still receive click events while hidden in the Classic session. Plus the dock now has an opaque style when “Panel Translucency” is turned off in System Settings → Desktop → Dock & Panel. Window Manager We have another huge release of our window manager thanks to Leonhard and Leo. This release fixes five potential crashes, over a dozen reported issues, fixes related to both the Classic and Secure sessions, issues related to HiDPI, and more, plus performance improvements. It’s worth reading the full release notes on GitHub if you have been waiting for the fix for a specific issue. And More OS 8.0.1 includes the latest long-term support Hardware Enablement stack from Ubuntu, including Linux 6.11. This brings improved performance for AMD processors, support for Intel “Lunar Lake” processors, and filesystem performance improvements in some cases. Plus support for certain webcams, USB network devices, joysticks, and more. Leo fixed an issue where connecting Bluetooth devices could cause the Lock Screen to freeze. You can now close the captive network assistant with the keyboard shortcut Ctrl + Q, thanks to Stanisław. And Alain fixed copying screenshots to the clipboard. We fixed an issue where wired network connections could fail to connect due to a change in Ubuntu. We’re pursuing this issue upstream and working on a way to ship the fix as an update, but for now fixing this issue requires either manual intervention through Terminal or a reinstall. We also now pre-install an AppArmor profile that fixes a number of Flatpak-related issues like not being to install certain runtime updates or apps not launching in the guest session or Demo mode. Special thanks to Uncle Tallest for investigating this issue and helping folks in our Discord who ran into it. And of course this release comes with a ton of translation updates! Special thanks to our hard-working internationalization community and especially Ryo who fixed a number of issues with things that couldn’t be localized properly in the previous release. Get elementary OS 8.0.1 elementary OS 8.0.1 is available as a pay-what-you-can purchase at elementary.io today. Localized direct downloads and a torrent magnet link are provided. OS 8 FAQ Download elementary OS 8.0.1 Sponsors have been able to download OS 8.0.1 release candidates since last week, so if getting things before anyone else is important to you, consider sponsoring us on GitHub

a month ago 19 votes
Happy Holidays! We Come Bringing Gifts!

It’s only been a little over 2 weeks since we released elementary OS 8, but we’re already back with updates just in time for the holidays! Terminal The headliner this month is Terminal which comes with a bunch of fixes and new features thanks to Jeremy. It now uses the more modern tab bar widget you’re used to from Web, Files, and Code. There’s an overlay bar that shows the current zoom level when it changes. We do a better job of handling URIs which contain spaces. And we now show unsafe paste warnings for Drag n Drop operations. Plus, we now show the unsafe paste warning for more commands like doas thanks to Elsie and there’s a new option in the gear menu to toggle unsafe paste alerts thanks to Stella and Charlie. Michal upped the contrast for gray in our default style and Igor made sure we focus the relevant tab when notifications are clicked. Plus, we now replace notifications from the same tab and withdraw notifications when a tab is focused, so your notification center should be a lot less noisy. This release was really a group effort with several new contributors, so major shoutouts to everyone who worked on it! AppCenter AppCenter will use Dark Mode screenshots when available Thanks to Italo, AppCenter will now use provided dark mode screenshots and brand colors when developers provide them. Plus, he addressed a visual bug with release notes. And Juan added support for the latest Appstream Developer tag, so we’re staying up on standards. Window Manager & Dock In the Window Manager, Leo fixed an issue where the dock could sometimes still be clicked when hidden in the Classic session, while Leonhard contributed some performance improvements. In the Dock, Leonhard made sure launcher bounces don’t run too long for apps that don’t notify on startup. Leo fixed an issue where launchers with large icons could become clipped while they bounce and made sure running indicators have a bit more room to breath. Plus the dock now also respects the “Panel Translucency” setting, making it completely solid when requested for added contrast. System Settings Alain added some visual polish to the System view as well as a new progress bar that represents how close we are to meeting our monthly sponsorship goal. Plus Leonhard made sure automatic updates won’t download on metered networks, and we avoid checking for system updates altogether in Demo Mode. We now show monthly funding goal progress right in System Settings You can now prevent Apps from sending notifications from Applications → Permissions, even for apps that don’t report their notification usage in Notification settings. and the check mark next to the current language in Language & Region settings will now follow your accent color thanks to Leo. Installation & Onboarding David fixed a crash with certain partitioning schemes in the Installer’s custom install view, and the encrypt view was simplified. Onboarding will now always stay centered on the screen, even when resized. Icon Browser A new version of the Icon Browser for app developers is available in AppCenter that includes the latest icons for Platform 8 as well as a quick button for copying code snippets thanks to Ryo. And we now focus the search automatically when you start typing, thanks to Alain. And More You can now close the captive network assistant with the keyboard shortcut Ctrl + Q, thanks to Stanisław. Alain fixed copying screenshots to the clipboard. And there a ton of translation updates, especially including traditional Chinese thanks to Kisaragi. Sponsors At the moment we’re at 22% of our monthly funding goal and 430 Sponsors on GitHub! Shoutouts to everyone helping us reach our goals here. Your monthly sponsorship funds development and makes sure we have the resources we need to give you the best version of elementary OS we can! Monthly release candidate builds and daily Early Access builds are available to GitHub Sponsors from any tier! Beware that Early Access builds are not considered stable and you will encounter fresh issues when you run them. We’d really appreciate reporting any problems you encounter with the Feedback app or directly on GitHub.

4 months ago 65 votes
Package Releases Are Almost Done, You Won't Believe What Happens Next!

This month’s update is fairly brief since a lot of what we did last month was minor bug fixes, regression testing, updating metadata, taking screenshots, and releasing packages. We’re getting down to the last few items before we can release elementary OS 8. Read ahead to find out more! OS 7 Updates Just a couple of small OS 7 updates this month! Ryan backported a fix for an issue in AppCenter where the updates page would continue to show the loading screen after it was finished loading. And the latest Network Indicator was released and now shows cellular modems as toggle buttons like it does with other devices. Cellular modems now show as toggle buttons OS 8 Updates Continuing on with our work to vastly improve screen reader support this cycle, Leo implemented the accessibility interface in the Alt + Tab window switcher! Leonhard added a new option to the system shutdown dialog so you can choose to skip a pending update, even when automatic updates are enabled. You can choose to skip updates when shutting down or restarting If you have a mixed-dpi setup—like a HiDPI laptop or tablet and a LoDPI external monitor—You can now set per-display scaling in the Secure Session thanks to Leonhard. And power modes can also now be quickly changed from the power indicator thanks to Subhadeep. Power modes now appear in the power indicator Release Planning Last month we finished releasing nearly every component that makes up elementary OS—over 80 packages. The only thing left is the Login & Lock Screen which is blocked by two small issues. We also have just two more OS patches to complete. Once these issues are resolved and the Login & Lock Screen has a package release, we can build release-candidate images of elementary OS 8 from the stable updates channel—and these builds will be available to Sponsors in Early Access right away. There’s still a couple more issues we want to try to solve before the final public OS 8 release, but we’re very close! As always you can follow along with our progress towards the release of OS 8 in this GitHub project. When this project board is empty, it’s public release time! Sponsors At the moment we’re at 20% of our monthly funding goal and 385 Sponsors on GitHub! Shoutouts to everyone helping us reach our goals here. Your monthly sponsorship funds development and makes sure we have the resources we need to give you the best version of elementary OS we can! Monthly release candidate builds and daily Early Access builds are available to GitHub Sponsors from any tier! Beware that Early Access builds are not considered stable and you will encounter fresh issues when you run them. We’d really appreciate reporting any problems you encounter with the Feedback app or directly on GitHub.

7 months ago 68 votes
Surprise! Big Updates for OS 7 Are Here!

This month we have a bunch of surprise updates for OS 7 and as always a progress update on OS 8. We’re getting very close to releasing the latest version of our operating system and that means releasing new versions of all of the projects we maintain! That means big new versions of apps and new platform features, some of which we’re also able to release as an update for OS 7. Community Just a little follow up on our Discord community: we’re now just over 550 members! It’s quickly becoming a great place to ask questions and get help, share ideas, and generally hang out and chat with other people who use elementary OS or run Pantheon on other Linux distributions. It’s been really fun to watch this server grow and I’m really excited to participate more in a much less formal way with our community. Join us on Discord OS 7 Updates While most of the releases going out at the moment are exclusive to OS 8, there were still a number of significant updates that we were able to release for OS 7! This is in large part due to shipping many of our apps as Flatpak packages, but it also includes a sneaky platform update that you might not even know you needed. Videos Videos has a new modern and minimalist design Videos now sports a more modern and minimal design which is especially apparent on the player page. On the library page it uses larger landscape format thumbnails and the app now follows the system light and dark style preference. The upgrade to GTK4 also brings performance improvements. Major shoutouts to Leonhard for his work modernizing this code base. Videos—like all of our Flatpak apps—is of course also available to download as a Flatpak for folks running Linux distros other than elementary OS: Download Videos as Flatpak Developer Tools Code now uses the LibHandy tab bar widget which brings improved animations and drag-n-drop behavior. The Terminal pane can now open to your preference of project subdirectory by default. The preferences dialog was slightly redesigned to fit more modern platform conventions and improve screen reader compatibility. And we fixed a dozen reported issues! There’s a new setting in Terminal for event alerts on invalid input and we now do a better job saving tab state. Plus man page documentation has been improved. Restoring tabs from last time is now optional in Files and it now supports hiding files and folders via a .hidden file, a feature you may be familiar with from other file manager apps. Special thanks go to Colin, Gustavo, and Jeremy for working on our developer tools. Portals Portals are special API that apps can use to access system features in a way that respects your privacy and requires your explicit consent. Three new Portals are now supported in OS 7: Color Picker, Screenshot, and Screencast. These portals are essential for maintaining compatibility with modern apps which are written to work in a Wayland world and don’t have direct access to the pixels on your display. If you’ve previously experienced trouble using modern color picker or screen recording apps from alt stores like Flathub on elementary OS 7, this update should fix that for you! Thanks to Davidand Leonhard for their work here! And More Music can now open individual audio files from within the app instead of requiring you to open them from within Files and it gains the now-familiar sticky toolbar style when scrolling in the queue. Camera has been updated to use GTK4 which for now simply means improved performance. And a new Tasks release fixes an issue where it would crash when the system style was changed from light to dark. OS 8 Updates We’ve landed a rename of the session options on the Lock Screen to hopefully improve clarity for folks that aren’t sure if they should be using a Wayland or X11 session. The X11 session is now called the “Compatibility Session” since it offers improved compatibility with legacy apps and some accessibility tools. The Wayland session is now called the “Secure Session” since it requires apps to use modern APIs that improve your security and respect your privacy. There was a lot of back-and-forth discussion about the best way to concisely describe these sessions in a non-technical way—we’re aware these descriptions are not perfect—and we think that for now this the best way to sum up the trade offs when selecting a session. In the future this may change as new features may rely on Wayland and the performance benefits of Wayland become more distinct. But for now we want to make sure that folks who rely on the X11 session for certain workflows aren’t being discouraged by a word choice that doesn’t reflect their reality. And speaking of the compatibility session—pending approval of a new window manager protocol—we will be able to ship the new Dock in both the Secure and Compatibility sessions in OS 8. This is particularly great news since the new Dock offers a much better multitasking workflow based on the feedback we gathered in our survey; For those times you may need to switch back to the Compatibility session for certain apps you won’t need to manage disparate dock settings. Navigation in Onboarding has been rewritten for improved accessibility and with a neat progress bar On the heels of some of our recent accessibility work, I’m proud to say that navigation in Onboarding has been rewritten for much improved keyboard navigation and screen reader compatibility. This was a show stopper when Florian took a look at OS 8 in June. Onboarding is such an important part of introducing a new operating system and making sure people new to elementary OS have a great time, so I’m particularly glad to improve this first impression for folks with vision-related disabilities. The Bluetooth Daemon was previously shipped in the same package as the Bluetooth Indicator and it now lives in its own separate package and has its own project. This should both make it clearer which components are responsible for which parts of Bluetooth features on elementary OS and make things a bit easier to maintain. For now features remain completely unchanged and this is purely organizational. We’re also now shipping Font Viewer as a Flatpak app. Previously we had packaged it and released it to AppCenter, but it is now pulled into OS 8 daily by default. This means we can continually ship the latest GNOME Font Viewer in elementary OS built against our Flatpak runtime so that it fits in stylistically. Release Planning Nearly everything is now released in the OS 8 stable repository, which means we’re very close to building stable release candidate quality builds for OS 8 in Early Access. At the moment we’re mainly waiting on the new Window Manager protocol for the Dock in the compatibility session which will unblock releases for the Dock and Panel. As always you can follow along with our progress towards the release of OS 8 in this GitHub project. At this rate we may be looking at a September release of OS 8 if everything goes smoothly; keep your fingers crossed! Sponsors At the moment we’re just above 21% of our monthly funding goal and we’re at 382 Sponsors on GitHub! Shoutouts to everyone helping us reach our goals here. Your monthly sponsorship funds development and makes sure we have the resources we need to give you the best version of elementary OS we can! Monthly release candidate builds and daily Early Access builds are available to GitHub Sponsors from any tier! Beware that Early Access builds are not considered stable and you will encounter fresh issues when you run them. We’d really appreciate reporting any problems you encounter with the Feedback app or directly on GitHub.

8 months ago 67 votes

More in programming

We'll always need junior programmers

We received over 2,200 applications for our just-closed junior programmer opening, and now we're going through all of them by hand and by human. No AI screening here. It's a lot of work, but we have a great team who take the work seriously, so in a few weeks, we'll be able to invite a group of finalists to the next phase. This highlights the folly of thinking that what it'll take to land a job like this is some specific list of criteria, though. Yes, you have to present a baseline of relevant markers to even get into consideration, like a great cover letter that doesn't smell like AI slop, promising projects or work experience or educational background, etc. But to actually get the job, you have to be the best of the ones who've applied! It sounds self-evident, maybe, but I see questions time and again about it, so it must not be. Almost every job opening is grading applicants on the curve of everyone who has applied. And the best candidate of the lot gets the job. You can't quantify what that looks like in advance. I'm excited to see who makes it to the final stage. I already hear early whispers that we got some exceptional applicants in this round. It would be great to help counter the narrative that this industry no longer needs juniors. That's simply retarded. However good AI gets, we're always going to need people who know the ins and outs of what the machine comes up with. Maybe not as many, maybe not in the same roles, but it's truly utopian thinking that mankind won't need people capable of vetting the work done by AI in five minutes.

11 hours ago 4 votes
Requirements change until they don't

Recently I got a question on formal methods1: how does it help to mathematically model systems when the system requirements are constantly changing? It doesn't make sense to spend a lot of time proving a design works, and then deliver the product and find out it's not at all what the client needs. As the saying goes, the hard part is "building the right thing", not "building the thing right". One possible response: "why write tests"? You shouldn't write tests, especially lots of unit tests ahead of time, if you might just throw them all away when the requirements change. This is a bad response because we all know the difference between writing tests and formal methods: testing is easy and FM is hard. Testing requires low cost for moderate correctness, FM requires high(ish) cost for high correctness. And when requirements are constantly changing, "high(ish) cost" isn't affordable and "high correctness" isn't worthwhile, because a kinda-okay solution that solves a customer's problem is infinitely better than a solid solution that doesn't. But eventually you get something that solves the problem, and what then? Most of us don't work for Google, we can't axe features and products on a whim. If the client is happy with your solution, you are expected to support it. It should work when your customers run into new edge cases, or migrate all their computers to the next OS version, or expand into a market with shoddy internet. It should work when 10x as many customers are using 10x as many features. It should work when you add new features that come into conflict. And just as importantly, it should never stop solving their problem. Canonical example: your feature involves processing requested tasks synchronously. At scale, this doesn't work, so to improve latency you make it asynchronous. Now it's eventually consistent, but your customers were depending on it being always consistent. Now it no longer does what they need, and has stopped solving their problems. Every successful requirement met spawns a new requirement: "keep this working". That requirement is permanent, or close enough to decide our long-term strategy. It takes active investment to keep a feature behaving the same as the world around it changes. (Is this all a pretentious of way of saying "software maintenance is hard?" Maybe!) Phase changes In physics there's a concept of a phase transition. To raise the temperature of a gram of liquid water by 1° C, you have to add 4.184 joules of energy.2 This continues until you raise it to 100°C, then it stops. After you've added two thousand joules to that gram, it suddenly turns into steam. The energy of the system changes continuously but the form, or phase, changes discretely. Software isn't physics but the idea works as a metaphor. A certain architecture handles a certain level of load, and past that you need a new architecture. Or a bunch of similar features are independently hardcoded until the system becomes too messy to understand, you remodel the internals into something unified and extendable. etc etc etc. It's doesn't have to be totally discrete phase transition, but there's definitely a "before" and "after" in the system form. Phase changes tend to lead to more intricacy/complexity in the system, meaning it's likely that a phase change will introduce new bugs into existing behaviors. Take the synchronous vs asynchronous case. A very simple toy model of synchronous updates would be Set(key, val), which updates data[key] to val.3 A model of asynchronous updates would be AsyncSet(key, val, priority) adds a (key, val, priority, server_time()) tuple to a tasks set, and then another process asynchronously pulls a tuple (ordered by highest priority, then earliest time) and calls Set(key, val). Here are some properties the client may need preserved as a requirement: If AsyncSet(key, val, _, _) is called, then eventually db[key] = val (possibly violated if higher-priority tasks keep coming in) If someone calls AsyncSet(key1, val1, low) and then AsyncSet(key2, val2, low), they should see the first update and then the second (linearizability, possibly violated if the requests go to different servers with different clock times) If someone calls AsyncSet(key, val, _) and immediately reads db[key] they should get val (obviously violated, though the client may accept a slightly weaker property) If the new system doesn't satisfy an existing customer requirement, it's prudent to fix the bug before releasing the new system. The customer doesn't notice or care that your system underwent a phase change. They'll just see that one day your product solves their problems, and the next day it suddenly doesn't. This is one of the most common applications of formal methods. Both of those systems, and every one of those properties, is formally specifiable in a specification language. We can then automatically check that the new system satisfies the existing properties, and from there do things like automatically generate test suites. This does take a lot of work, so if your requirements are constantly changing, FM may not be worth the investment. But eventually requirements stop changing, and then you're stuck with them forever. That's where models shine. As always, I'm using formal methods to mean the subdiscipline of formal specification of designs, leaving out the formal verification of code. Mostly because "formal specification" is really awkward to say. ↩ Also called a "calorie". The US "dietary Calorie" is actually a kilocalorie. ↩ This is all directly translatable to a TLA+ specification, I'm just describing it in English to avoid paying the syntax tax ↩

8 hours ago 2 votes
How should Stripe deprecate APIs? (~2016)

While Stripe is a widely admired company for things like its creation of the Sorbet typer project, I personally think that Stripe’s most interesting strategy work is also among its most subtle: its willingness to significantly prioritize API stability. This strategy is almost invisible externally. Internally, discussions around it were frequent and detailed, but mostly confined to dedicated API design conversations. API stability isn’t just a technical design quirk, it’s a foundational decision in an API-driven business, and I believe it is one of the unsung heroes of Stripe’s business success. This is an exploratory, draft chapter for a book on engineering strategy that I’m brainstorming in #eng-strategy-book. As such, some of the links go to other draft chapters, both published drafts and very early, unpublished drafts. Reading this document To apply this strategy, start at the top with Policy. To understand the thinking behind this strategy, read sections in reverse order, starting with Explore. More detail on this structure in Making a readable Engineering Strategy document. Policy & Operation Our policies for managing API changes are: Design for long API lifetime. APIs are not inherently durable. Instead we have to design thoughtfully to ensure they can support change. When designing a new API, build a test application that doesn’t use this API, then migrate to the new API. Consider how integrations might evolve as applications change. Perform these migrations yourself to understand potential friction with your API. Then think about the future changes that we might want to implement on our end. How would those changes impact the API, and how would they impact the application you’ve developed. At this point, take your API to API Review for initial approval as described below. Following that approval, identify a handful of early adopter companies who can place additional pressure on your API design, and test with them before releasing the final, stable API. All new and modified APIs must be approved by API Review. API changes may not be enabled for customers prior to API Review approval. Change requests should be sent to api-review email group. For examples of prior art, review the api-review archive for prior requests and the feedback they received. All requests must include a written proposal. Most requests will be approved asynchronously by a member of API Review. Complex or controversial proposals will require live discussions to ensure API Review members have sufficient context before making a decision. We never deprecate APIs without an unavoidable requirement to do so. Even if it’s technically expensive to maintain support, we incur that support cost. To be explicit, we define API deprecation as any change that would require customers to modify an existing integration. If such a change were to be approved as an exception to this policy, it must first be approved by the API Review, followed by our CEO. One example where we granted an exception was the deprecation of TLS 1.2 support due to PCI compliance obligations. When significant new functionality is required, we add a new API. For example, we created /v1/subscriptions to support those workflows rather than extending /v1/charges to add subscriptions support. With the benefit of hindsight, a good example of this policy in action was the introduction of the Payment Intents APIs to maintain compliance with Europe’s Strong Customer Authentication requirements. Even in that case the charge API continued to work as it did previously, albeit only for non-European Union payments. We manage this policy’s implied technical debt via an API translation layer. We release changed APIs into versions, tracked in our API version changelog. However, we only maintain one implementation internally, which is the implementation of the latest version of the API. On top of that implementation, a series of version transformations are maintained, which allow us to support prior versions without maintaining them directly. While this approach doesn’t eliminate the overhead of supporting multiple API versions, it significantly reduces complexity by enabling us to maintain just a single, modern implementation internally. All API modifications must also update the version transformation layers to allow the new version to coexist peacefully with prior versions. In the future, SDKs may allow us to soften this policy. While a significant number of our customers have direct integrations with our APIs, that number has dropped significantly over time. Instead, most new integrations are performed via one of our official API SDKs. We believe that in the future, it may be possible for us to make more backwards incompatible changes because we can absorb the complexity of migrations into the SDKs we provide. That is certainly not the case yet today. Diagnosis Our diagnosis of the impact on API changes and deprecation on our business is: If you are a small startup composed of mostly engineers, integrating a new payments API seems easy. However, for a small business without dedicated engineers—or a larger enterprise involving numerous stakeholders—handling external API changes can be particularly challenging. Even if this is only marginally true, we’ve modeled the impact of minimizing API changes on long-term revenue growth, and it has a significant impact, unlocking our ability to benefit from other churn reduction work. While we believe API instability directly creates churn, we also believe that API stability directly retains customers by increasing the migration overhead even if they wanted to change providers. Without an API change forcing them to change their integration, we believe that hypergrowth customers are particularly unlikely to change payments API providers absent a concrete motivation like an API change or a payment plan change. We are aware of relatively few companies that provide long-term API stability in general, and particularly few for complex, dynamic areas like payments APIs. We can’t assume that companies that make API changes are ill-informed. Rather it appears that they experience a meaningful technical debt tradeoff between the API provider and API consumers, and aren’t willing to consistently absorb that technical debt internally. Future compliance or security requirements—along the lines of our upgrade from TLS 1.2 to TLS 1.3 for PCI—may necessitate API changes. There may also be new tradeoffs exposed as we enter new markets with their own compliance regimes. However, we have limited ability to predict these changes at this point.

6 hours ago 1 votes
Bike Brooklyn! zine

I've been biking in Brooklyn for a few years now! It's hard for me to believe it, but I'm now one of the people other bicyclists ask questions to now. I decided to make a zine that answers the most common of those questions: Bike Brooklyn! is a zine that touches on everything I wish I knew when I started biking in Brooklyn. A lot of this information can be found in other resources, but I wanted to collect it in one place. I hope to update this zine when we get significantly more safe bike infrastructure in Brooklyn and laws change to make streets safer for bicyclists (and everyone) over time, but it's still important to note that each release will reflect a specific snapshot in time of bicycling in Brooklyn. All text and illustrations in the zine are my own. Thank you to Matt Denys, Geoffrey Thomas, Alex Morano, Saskia Haegens, Vishnu Reddy, Ben Turndorf, Thomas Nayem-Huzij, and Ryan Christman for suggestions for content and help with proofreading. This zine is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License, so you can copy and distribute this zine for noncommercial purposes in unadapted form as long as you give credit to me. Check out the Bike Brooklyn! zine on the web or download pdfs to read digitally or print here!

yesterday 5 votes
Announcing Hotwire Native 1.2

We’ve just launched Hotwire Native v1.2 and it’s the biggest update since the initial launch last year. The update has several key improvements, bug fixes, and more API consistency between platforms. And we’ve created all new iOS and Android demo apps to show it off! A web-first framework for building native mobile apps Improvements There are a few significant changes in v1.2 that are worth specifically highlighting. Route decision handlers Hotwire Native apps route internal urls to screens in your app, and route external urls to the device’s browser. Historically, though, it wasn’t straightforward to customize the default behavior for unique app needs. In v1.2, we’ve introduced the RouteDecisionHandler concept to iOS (formerly only on Android). Route decisions handlers offer a flexible way to decide how to route urls in your app. Out-of-the-box, Hotwire Native registers these route decision handlers to control how urls are routed: AppNavigationRouteDecisionHandler: Routes all internal urls on your app’s domain through your app. SafariViewControllerRouteDecisionHandler: (iOS Only) Routes all external http/https urls to a SFSafariViewController in your app. BrowserTabRouteDecisionHandler: (Android Only) Routes all external http/https urls to a Custom Tab in your app. SystemNavigationRouteDecisionHandler: Routes all remaining external urls (such as sms: or mailto:) through device’s system navigation. If you’d like to customize this behavior you can register your own RouteDecisionHandler implementations in your app. See the documentation for details. Server-driven historical location urls If you’re using Ruby on Rails, the turbo-rails gem provides the following historical location routes. You can use these to manipulate the navigation stack in Hotwire Native apps. recede_or_redirect_to(url, **options) — Pops the visible screen off of the navigation stack. refresh_or_redirect_to(url, **options) — Refreshes the visible screen on the navigation stack. resume_or_redirect_to(url, **options) — Resumes the visible screen on the navigation stack with no further action. In v1.2 there is now built-in support to handle these “command” urls with no additional path configuration setup necessary. We’ve also made improvements so they handle dismissing modal screens automatically. See the documentation for details. Bottom tabs When starting with Hotwire Native, one of the most common questions developers ask is how to support native bottom tab navigation in their apps. We finally have an official answer! We’ve introduced a HotwireTabBarController for iOS and a HotwireBottomNavigationController for Android. And we’ve updated the demo apps for both platforms to show you exactly how to set them up. New demo apps To better show off all the features in Hotwire Native, we’ve created new demo apps for iOS and Android. And there’s a brand new Rails web app for the native apps to leverage. Hotwire Native demo app Clone the GitHub repos to build and run the demo apps to try them out: iOS repo Android repo Rails app Huge thanks to Joe Masilotti for all the demo app improvements. If you’re looking for more resources, Joe even wrote a Hotwire Native for Rails Developers book! Release notes v1.2 contains dozens of other improvements and bug fixes across both platforms. See the full release notes to learn about all the additional changes: iOS release notes Android release notes Take a look If you’ve been curious about using Hotwire Native for your mobile apps, now is a great time to take a look. We have documentation and guides available on native.hotwired.dev and we’ve created really great demo apps for iOS and Android to help you get started.

yesterday 3 votes