# conditionals

Conditionals are programming-language control-flow constructs that choose and execute different code paths based on whether tests or predicates evaluate as true or false, including forms such as if, cond, and case.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Causal Discovery with False Positive Error Control

DevFeed: [Causal Discovery with False Positive Error Control](<https://devfeed.tech/articles/causal-discovery-with-false-positive-error-control-145047.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.25376>)

Author: Erik Jahn, Venkat Chandrasekaran, Frederick Eberhardt, Leonard Schulman

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [causality](<https://devfeed.tech/topics/causality.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [conditional](<https://devfeed.tech/tags/conditional.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [error-control](<https://devfeed.tech/tags/error-control.md>), [faithfulness](<https://devfeed.tech/tags/faithfulness.md>), [false-positive](<https://devfeed.tech/tags/false-positive.md>), [gaussian](<https://devfeed.tech/tags/gaussian.md>), [graph](<https://devfeed.tech/tags/graph.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [sample](<https://devfeed.tech/tags/sample.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>)

### AI overview

The m-conservative PC algorithm controls false discovery rate for causal graphs in the linear Gaussian setting under an extremely weak faithfulness assumption, with guarantees that hold in finite samples despite possible errors in conditional-independence tests. It defines false positives through the conditional-independence information implied by a graph, penalizing both false adjacencies and incorrect edge orientations. The method combines undirected graph learning, a Benjamini-Yekutieli-style conditional-independence testing procedure, and conservative orientation that leaves unresolved or contradictory directions ambiguous. Its parameter m trades algorithmic complexity against the strength of the required faithfulness assumption.

### Source excerpt

arXiv:2611.25376v1 Announce Type: cross Abstract: Causal discovery methods produce data-driven hypotheses about causal relationships, which may become new scientific findings or inform decisions about downstream interventions. In such settings, false positive causal claims can be more consequential than false negatives. Yet few methods target false positive error control in causal discovery, and existing error guarantees are often asymptotic and require strong versions of the faithfulness assumption. We introduce the $m$-conservative PC algorithm and prove that it controls false discovery rate in the linear Gaussian setting under an extremely weak version of the faithfulness assumption. In our framework, false positive error for causal graphs is defined based on the conditional-independence information they entail, yielding a metric that penalizes both false adjacencies and incorrect edge orientations. The parameter $m$ quantifies a trade-off between algorithmic complexity and the strength of the required faithfulness assumption. The $m$-conservative PC algorithm combines undirected graph learning, a Benjamini-Yekutieli-style procedure for conditional independence testing, and a conservative orientation step that marks unresolved or contradictory edge directions as ambiguous. Our algorithm produces valid outputs and retains error guarantees even in the finite-sample setting, despite possible random errors in the conditional independence tests.

## Clean Up Your Conditional Logic: Exploring Kotlin 2.5.0-Beta2's New Boolean & Nullable Utilities

DevFeed: [Clean Up Your Conditional Logic: Exploring Kotlin 2.5.0-Beta2's New Boolean & Nullable Utilities](<https://devfeed.tech/articles/clean-up-your-conditional-logic-exploring-kotlin-2-5-0-beta2-s-new-boolean-nullable-utilities-122284.md>)

Original publisher: [Read original article](<https://proandroiddev.com/clean-up-your-conditional-logic-exploring-kotlin-2-5-0-beta2s-new-boolean-nullable-utilities-7854207156ea?source=rss----c72404660798---4>)

Author: Nav Singh

Published: 2026-11-07T16:39:54Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>), [if statement](<https://devfeed.tech/topics/if-statement.md>), [Null-Safety](<https://devfeed.tech/topics/null-safety.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [scope function](<https://devfeed.tech/topics/scope-function.md>)

Tags: [also](<https://devfeed.tech/tags/also.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [annotation](<https://devfeed.tech/tags/annotation.md>), [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [apply](<https://devfeed.tech/tags/apply.md>), [boilerplate](<https://devfeed.tech/tags/boilerplate.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [chaining](<https://devfeed.tech/tags/chaining.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [condition](<https://devfeed.tech/tags/condition.md>), [data-class](<https://devfeed.tech/tags/data-class.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [functions](<https://devfeed.tech/tags/functions.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-2](<https://devfeed.tech/tags/kotlin-2.md>), [lambda](<https://devfeed.tech/tags/lambda.md>), [let](<https://devfeed.tech/tags/let.md>), [receiver](<https://devfeed.tech/tags/receiver.md>), [scope-functions](<https://devfeed.tech/tags/scope-functions.md>), [standard-library](<https://devfeed.tech/tags/standard-library.md>)

### AI overview

Kotlin 2.5.0-Beta2 introduces experimental standard-library helpers for conditional work: `onTrue` and `onFalse` run a supplied block when a Boolean matches, then return that Boolean unchanged; `ifOrNull` lazily computes and returns a value when its condition is true, or returns null when false. The excerpt shows using the Boolean helpers for authentication side effects and `ifOrNull` to produce a phone number only when contact information is available. Use requires opting in to `ExperimentalStdlibApi`, either at the function or file level or through Gradle language settings. The excerpt does not establish broader API availability or stability.

### Source excerpt

AI generated image Ditch redundant if-else boilerplate and awkward scope chaining with the newly introduced onTrue(), onFalse(), and ifOrNull() functions. Kotlin has always excelled at eliminating boilerplate. From concise data classes and standard scope functions (apply, also, let, takeIf) to smart casting, the language consistently seeks ways to make everyday idioms more expressive. Kotlin 2.5.0-Beta2 adds standard library functions that let us inspect a value before returning it, or return a nullable result based on that value. https://kotlinlang.org/docs/whatsnew-eap.html?utm_campaign=kotlin-releases&utm_content=2-5-0-beta2 Boolean.onTrue(action: () -> Unit): Boolean Boolean.onFalse(action: () -> Unit): Boolean ifOrNull(condition: Boolean, action: () -> T): T? Implementation Because these functions are introduced as experimental APIs in the standard library, we need to opt in to use them. File/Function Annotation OptIn(ExperimentalStdlibApi::class) Module-wide via Gradle config kotlin { sourceSets.all { languageSettings.optIn("kotlin.ExperimentalStdlibApi") } }onTrue() & onFalse() Both functions invoke a supplied block when the receiver matches the condition and return the original boolean unmodified. Example data class User(val id: String, val email: String) class AuthService() { // Before: fun authenticateLegacy(user: User, token: String): Boolean { val isValid = verifyToken(user.email, token) if (isValid) { "Auth.success" } else { "Auth.failure" } return isValid } // Now: @OptIn(ExperimentalStdlibApi::class) fun authenticate(user: User, token: String): Boolean = verifyToken(user.email, token) .onTrue { "Auth.success" } .onFalse { "Auth.failure" } }ifOrNull() When shaping API responses or DTOs, we may return one computed value if a flag is true and another if false. Traditionally, this looks like 👇 val phoneNumber = if (user.hasContactInfo) user.phoneNumber else nullThe New Way: ifOrNull() ifOrNull(condition) { //.. } lazily evaluates the lambda block only if

## Clean Up Your Conditional Logic: Exploring Kotlin 2.5.0-Beta2's New Boolean & Nullable Utilities

DevFeed: [Clean Up Your Conditional Logic: Exploring Kotlin 2.5.0-Beta2's New Boolean & Nullable Utilities](<https://devfeed.tech/articles/clean-up-your-conditional-logic-exploring-kotlin-2-5-0-beta2-s-new-boolean-nullable-utilities-122052.md>)

Original publisher: [Read original article](<https://proandroiddev.com/clean-up-your-conditional-logic-exploring-kotlin-2-5-0-beta2s-new-boolean-nullable-utilities-7854207156ea?source=rss-711ab22c5c77------2>)

Author: Nav Singh

Published: 2026-11-07T02:22:10Z

Content type: tutorial

Language: en

Sources: [Nav Singh](<https://devfeed.tech/sources/stories-by-nav-singh-on-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>), [if statement](<https://devfeed.tech/topics/if-statement.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [scope function](<https://devfeed.tech/topics/scope-function.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [conditional](<https://devfeed.tech/tags/conditional.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-2](<https://devfeed.tech/tags/kotlin-2.md>), [standard-library](<https://devfeed.tech/tags/standard-library.md>)

### AI overview

Kotlin 2.5.0-Beta2 introduces three experimental standard-library utilities for conditional logic. `Boolean.onTrue` and `onFalse` run a supplied block when the Boolean matches, then return the original Boolean unchanged; the excerpt shows them used to trigger authentication messages while preserving the verification result. `ifOrNull(condition) { ... }` evaluates its block only when the condition is true, returning its value or `null`, as in the phone-number example. Use requires opting in with `ExperimentalStdlibApi`, either at a file or function or through the shown Gradle source-set setting. The supplied excerpt does not describe further behavior or limitations.

### Source excerpt

AI generated image Ditch redundant if-else boilerplate and awkward scope chaining with the newly introduced onTrue(), onFalse(), and ifOrNull() functions. Kotlin has always excelled at eliminating boilerplate. From concise data classes and standard scope functions (apply, also, let, takeIf) to smart casting, the language consistently seeks ways to make everyday idioms more expressive. Kotlin 2.5.0-Beta2 adds standard library functions that let us inspect a value before returning it, or return a nullable result based on that value. https://kotlinlang.org/docs/whatsnew-eap.html?utm_campaign=kotlin-releases&utm_content=2-5-0-beta2 Boolean.onTrue(action: () -> Unit): Boolean Boolean.onFalse(action: () -> Unit): Boolean ifOrNull(condition: Boolean, action: () -> T): T? Implementation Because these functions are introduced as experimental APIs in the standard library, we need to opt in to use them. File/Function Annotation OptIn(ExperimentalStdlibApi::class) Module-wide via Gradle config kotlin { sourceSets.all { languageSettings.optIn("kotlin.ExperimentalStdlibApi") } }onTrue() & onFalse() Both functions invoke a supplied block when the receiver matches the condition and return the original boolean unmodified. Example data class User(val id: String, val email: String) class AuthService() { // Before: fun authenticateLegacy(user: User, token: String): Boolean { val isValid = verifyToken(user.email, token) if (isValid) { "Auth.success" } else { "Auth.failure" } return isValid } // Now: @OptIn(ExperimentalStdlibApi::class) fun authenticate(user: User, token: String): Boolean = verifyToken(user.email, token) .onTrue { "Auth.success" } .onFalse { "Auth.failure" } }ifOrNull() When shaping API responses or DTOs, we may return one computed value if a flag is true and another if false. Traditionally, this looks like 👇 val phoneNumber = if (user.hasContactInfo) user.phoneNumber else nullThe New Way: ifOrNull() ifOrNull(condition) { //.. } lazily evaluates the lambda block only if

## Writing a DSL for high performance parallel programming in OxCaml

DevFeed: [Writing a DSL for high performance parallel programming in OxCaml](<https://devfeed.tech/articles/writing-a-dsl-for-high-performance-parallel-programming-in-oxcaml-132544.md>)

Original publisher: [Read original article](<https://blog.janestreet.com/writing-a-dsl-for-high-performance-parallel-programming-in-oxcaml/>)

Author: Nicholas Yang

Published: 2026-11-06T00:00:00Z

Content type: article

Language: en

Sources: [Jane Street](<https://devfeed.tech/sources/jane-street.md>)

Topics: [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [GPU](<https://devfeed.tech/topics/gpu.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [assembly](<https://devfeed.tech/tags/assembly.md>), [avx2](<https://devfeed.tech/tags/avx2.md>), [avx512](<https://devfeed.tech/tags/avx512.md>), [backend](<https://devfeed.tech/tags/backend.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [c](<https://devfeed.tech/tags/c.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [high-performance](<https://devfeed.tech/tags/high-performance.md>), [intern](<https://devfeed.tech/tags/intern.md>), [internship](<https://devfeed.tech/tags/internship.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [performance](<https://devfeed.tech/tags/performance.md>), [programming](<https://devfeed.tech/tags/programming.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The OxCaml DSL lets developers describe the computation for one output index in an SPMD kernel; its compiler builds a graph and uses runtime metaprogramming to specialize and compile OxCaml code for the chosen metric and target architecture. Kernels write each output entry once, enabling parallel execution. The compiler distinguishes uniform and per-lane values, and offers `if_`, `if_var` and `select`; unlike `select`, which evaluates both branches, `if_var` can skip an untaken branch. An A-normal-form IR makes transformations such as hoisting loop-invariant loads and processing four elements per loop iteration easier to represent and optimize. The initial JIT was much faster than the interpreter, about as fast as or slightly slower than manual OxCaml, and significantly slower than C AVX2/AVX512. The IR backend initially performed about the same as that JIT. Preliminary vectorization and constant-hoisting work brought results on par with C AVX2; scheduling improvements were still in progress, and the excerpt reports no final results for them.

### Source excerpt

The following is part of a series of posts about 2026 summer intern projects--for more, see "What the interns have wrought, special jumbo 2026 edition"

## CodeSOD: Death of the Auth-Er

DevFeed: [CodeSOD: Death of the Auth-Er](<https://devfeed.tech/articles/codesod-death-of-the-auth-er-115664.md>)

Original publisher: [Read original article](<https://thedailywtf.com/articles/death-of-the-auth-er>)

Author: Remy Porter

Published: 2026-11-03T06:30:00Z

Content type: article

Language: en

Sources: [The Daily WTF](<https://devfeed.tech/sources/the-daily-wtf.md>)

Topics: [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Exception handling](<https://devfeed.tech/topics/exception-handling.md>), [return](<https://devfeed.tech/topics/return.md>)

Tags: [auth](<https://devfeed.tech/tags/auth.md>), [code](<https://devfeed.tech/tags/code.md>), [codesod](<https://devfeed.tech/tags/codesod.md>), [conditionals](<https://devfeed.tech/tags/conditionals.md>), [death](<https://devfeed.tech/tags/death.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [perl](<https://devfeed.tech/tags/perl.md>), [production](<https://devfeed.tech/tags/production.md>)

### AI overview

The inherited `store()` handler is effectively disabled by unconditional `die` statements: it stops at `echo 'Hello'`, before attempting authentication. Further `die`s would also halt the success and failure paths, preventing the welcome response or redirect. The author speculates these statements were added while disabling the route path by path, but says the source history is unavailable; the code reportedly remained in production for years.

### Source excerpt

When writing Perl, it's not unusual to want to die. The die function ends your Perl program with an error string, and you'll often see code like: die "My error" unless $i > 5 or die "Other error" if check(), because Perl just loves the backwards conditionals. What's even more fun with die is how it behaves with eval blocks, so it doesn't always kill your program, sometimes it is how you pass error strings back out of sections of your program. And poor Bobby has inherited some Perl that just really loves to die. public function store() { echo 'Hello'; die; if (Auth::attempt(Input::only('email', 'password'))) { echo 'done'; die; // return "welcome ".Auth::user()->username } echo "Oops! Fails"; die; return Redirect::back()->with_input(); } Bobby didn't send the source control history here, but I have a sense of what it likely was like, once. If they authenticate successfully, print a welcome message. If they don't, redirect back to the logon page and let them try again. I suspect they wanted to disable the route. So first they disabled the success path, only to discover that the failure path kept redirecting, so they disabled that too. Finally, they added the Hello at the top to disable the whole thing. Why? Why did they do any of this? No idea. It feels like debugging code, but you'd expect more echos and fewer dies if that were the case. And you wouldn't expect it to leak into production and sit there for years, which is what happened here. [Advertisement] BuildMaster allows you to create a self-service release management platform that allows different teams to manage their applications. Explore how!

## Hardware-Aware Conditional Code in Android Apps

DevFeed: [Hardware-Aware Conditional Code in Android Apps](<https://devfeed.tech/articles/hardware-aware-conditional-code-in-android-apps-113486.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.00296>)

Author: Marco Alecci, Jordan Samhi, Li Li, Tegawend\\'e F. Bissyand\\'e, Jacques Klein

Published: 2026-11-03T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [if statement](<https://devfeed.tech/topics/if-statement.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-apps](<https://devfeed.tech/tags/android-apps.md>), [apis](<https://devfeed.tech/tags/apis.md>), [availability](<https://devfeed.tech/tags/availability.md>), [code](<https://devfeed.tech/tags/code.md>), [computer-science](<https://devfeed.tech/tags/computer-science.md>), [conditional](<https://devfeed.tech/tags/conditional.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [emulator](<https://devfeed.tech/tags/emulator.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [llm-assisted](<https://devfeed.tech/tags/llm-assisted.md>), [memory](<https://devfeed.tech/tags/memory.md>), [resource-management](<https://devfeed.tech/tags/resource-management.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [statement](<https://devfeed.tech/tags/statement.md>), [study](<https://devfeed.tech/tags/study.md>), [taxonomy](<https://devfeed.tech/tags/taxonomy.md>), [tiering](<https://devfeed.tech/tags/tiering.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

A static analysis of 50,000 Android apps found that 95% of successfully analyzed apps contain at least one conditional whose logic depends on hardware-related APIs, averaging 74 such statements per app. The researchers extracted conditions and branch code, then used LLM-assisted open coding to classify their purposes. The identified uses include checking feature availability, adapting the UI, detecting emulators, grouping devices into tiers, and managing resources. The study frames these findings as evidence that hardware-dependent logic is widespread; the supplied text does not describe the individual categories in further detail.

### Source excerpt

arXiv:2611.00296v1 Announce Type: new Abstract: Android OS runs on a highly diverse set of devices, spanning entry-level phones and flagships with substantially different hardware characteristics, including memory capacity, processors, displays, cameras, and sensors. Through APIs, apps can query device information at runtime, such as memory, hardware features, and manufacturer, among other device properties, allowing developers to execute different code paths on different devices. Existing studies cover only specific compatibility bugs or brand-specific behavior; however, the broader use of hardware information in app logic has not been comprehensively explored. We address this question with a large-scale empirical study of hardware-related if statements in Android apps. We statically analyze 50,000 apps to identify the if statements whose conditions depend on the values of hardware-related APIs, and extract their conditions together with the code of their branches. Our results show that 95% of successfully analyzed apps contain at least one such statement, with an average of 74 per app, which suggests that hardware-related logic is widespread. We then apply an LLM-assisted open-coding process to the extracted code to build a structured taxonomy of the purposes behind hardware-related conditional code. The resulting characterization shows that developers use hardware information for feature availability checks, UI adaptation, emulator detection, device tiering, and resource management, among others.

## Why do you have so many housekeeping jobs?

DevFeed: [Why do you have so many housekeeping jobs?](<https://devfeed.tech/articles/why-do-you-have-so-many-housekeeping-jobs-103481.md>)

Original publisher: [Read original article](<https://sqlperformance.com/2026/10/sql-maintenance/too-many-housekeeping-jobs>)

Author: Aaron Bertrand

Published: 2026-10-27T13:20:39Z

Content type: article

Language: en

Sources: [SQLPerformance.com](<https://devfeed.tech/sources/sqlperformance-com.md>)

Topics: [sql-server](<https://devfeed.tech/topics/sql-server.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [actions](<https://devfeed.tech/tags/actions.md>), [agent](<https://devfeed.tech/tags/agent.md>), [aging](<https://devfeed.tech/tags/aging.md>), [alerts](<https://devfeed.tech/tags/alerts.md>), [archive](<https://devfeed.tech/tags/archive.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [audit](<https://devfeed.tech/tags/audit.md>), [audit-trail](<https://devfeed.tech/tags/audit-trail.md>), [automatically](<https://devfeed.tech/tags/automatically.md>), [avoid](<https://devfeed.tech/tags/avoid.md>), [batch](<https://devfeed.tech/tags/batch.md>), [batching](<https://devfeed.tech/tags/batching.md>), [cons](<https://devfeed.tech/tags/cons.md>), [jobs](<https://devfeed.tech/tags/jobs.md>), [routine](<https://devfeed.tech/tags/routine.md>), [server](<https://devfeed.tech/tags/server.md>), [sql](<https://devfeed.tech/tags/sql.md>), [sql-job](<https://devfeed.tech/tags/sql-job.md>), [sql-maintenance](<https://devfeed.tech/tags/sql-maintenance.md>), [sql-performance](<https://devfeed.tech/tags/sql-performance.md>), [sql-server](<https://devfeed.tech/tags/sql-server.md>), [sql-server-agent](<https://devfeed.tech/tags/sql-server-agent.md>), [tasks](<https://devfeed.tech/tags/tasks.md>)

### AI overview

The author recommends selectively consolidating routine, infrequent SQL Server Agent housekeeping into ordered steps to reduce overlapping work and make schedules and activity easier to inspect. The article shows ways to run steps on specified weekdays using date arithmetic independent of language and DATEFIRST settings, and suggests checking whether a task has run since its last due date so missed runs can be recovered. It covers weekly SQL Server error log cycling and retention, Extended Events file rollover plus a PowerShell cleanup fallback, and frequent batched purges for potentially large histories. Consolidation has costs: shared failures or delays, reduced per-step visibility if steps are further combined, and faster exhaustion of bounded Agent history. The author advises deliberate failure handling, durable logging in a separately retained table, and external monitoring capable of checking SQL Server Agent itself. Some resource-intensive work may need fixed maintenance windows, and tasks with different owners, security contexts, or failure requirements may merit separate jobs.

### Source excerpt

Aaron Bertrand discusses the pros and cons of consolidating lots of SQL Server Agent jobs that perform routine housekeeping tasks. The post Why do you have so many housekeeping jobs? appeared first on SQLPerformance.com.

## CVE-2026-92885 - Qode Membership \<= 2.0.6.2 - Authentication Bypass via Social Login

DevFeed: [CVE-2026-92885 - Qode Membership \<= 2.0.6.2 - Authentication Bypass via Social Login](<https://devfeed.tech/articles/cve-2026-92885-qode-membership-2-0-6-2-authentication-bypass-via-social-login-101918.md>)

Original publisher: [Read original article](<https://cvefeed.io/vuln/detail/CVE-2026-92885>)

Author: CVEFEED.io; wordfence.com

Published: 2026-10-27T09:16:34Z

Content type: news

Language: en

Sources: [Latest High/Critical Vulnerabilitiy Feed](<https://devfeed.tech/sources/latest-high-critical-vulnerabilitiy-feed.md>)

Topics: [Authentication](<https://devfeed.tech/topics/authentication.md>), [account takeover](<https://devfeed.tech/topics/account-takeover.md>), [Secure token management](<https://devfeed.tech/topics/secure-token-management.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [account](<https://devfeed.tech/tags/account.md>), [account-takeover](<https://devfeed.tech/tags/account-takeover.md>), [administrator](<https://devfeed.tech/tags/administrator.md>), [ajax](<https://devfeed.tech/tags/ajax.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [authentication-bypass](<https://devfeed.tech/tags/authentication-bypass.md>), [cve-2026-92885](<https://devfeed.tech/tags/cve-2026-92885.md>), [exploitation](<https://devfeed.tech/tags/exploitation.md>), [facebook](<https://devfeed.tech/tags/facebook.md>), [graph](<https://devfeed.tech/tags/graph.md>), [login](<https://devfeed.tech/tags/login.md>), [network](<https://devfeed.tech/tags/network.md>), [oauth](<https://devfeed.tech/tags/oauth.md>), [plugin](<https://devfeed.tech/tags/plugin.md>), [public](<https://devfeed.tech/tags/public.md>), [token](<https://devfeed.tech/tags/token.md>), [variable](<https://devfeed.tech/tags/variable.md>), [verification](<https://devfeed.tech/tags/verification.md>), [wordpress](<https://devfeed.tech/tags/wordpress.md>)

### AI overview

Qode Membership for WordPress versions up to and including 2.0.6.2 has a critical authentication bypass in the Facebook social-login AJAX action. A variable-name typo makes the OAuth token verification guard ineffective, leaving the authentication-cookie function reachable without credential or token validation. An unauthenticated attacker could log in as an existing account, including an administrator, by providing its login name in the response[email] parameter. Exploitation requires a valid qode_validate_facebook_login nonce, which the excerpt says is available on public pages using the [qode_user_login] or [qode_user_register] shortcode. The excerpt rates the issue CVSS 9.8.

### Source excerpt

CVE ID :CVE-2026-92885 Published : Oct. 27, 2026, 9:16 a.m. | 1 hour, 28 minutes ago Description :The Qode Membership plugin for WordPress is vulnerable to Authentication Bypass leading to Account Takeover in all versions up to, and including, 2.0.6.2 via the qode_membership_check_facebook_user AJAX action. This is due to a typographic error in the Facebook OAuth token verification guard within the qode_membership_login_user_from_social_network function -- the guard condition tests an undefined variable ($check_social_useqoder instead of $check_social_user), causing empty() to always return true and rendering the Graph API token verification branch dead code, leaving wp_set_auth_cookie() reachable with no credential or token validation whatsoever. This makes it possible for unauthenticated attackers to log in as any existing WordPress account -- including Administrator-level accounts -- by supplying a known or enumerated administrator login name (rather than an email address) in the response[email] parameter, which the fallback path in get_user_by('login', $email) resolves to the matching account. Exploitation does require harvesting a valid qode_validate_facebook_login nonce, but this nonce is rendered on any public front-end page containing the [qode_user_login] or [qode_user_register] shortcode and is therefore obtainable without any prior authentication. Severity: 9.8 | CRITICAL Visit the link for more details, such as CVSS details, affected products, timeline, and more...

## Fuzzers vs. AI: Comparing Fuzzilli and BigSleep on JavaScript Engines

DevFeed: [Fuzzers vs. AI: Comparing Fuzzilli and BigSleep on JavaScript Engines](<https://devfeed.tech/articles/fuzzers-vs-ai-comparing-fuzzilli-and-bigsleep-on-javascript-engines-102546.md>)

Original publisher: [Read original article](<https://projectzero.google/2026/10/fuzzing-v-AI.html>)

Author: Samuel Groß

Published: 2026-10-27T07:00:00Z

Content type: news

Language: en

Sources: [Project Zero](<https://devfeed.tech/sources/project-zero.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [V8](<https://devfeed.tech/topics/v8.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [generative-ai-tools](<https://devfeed.tech/topics/generative-ai-tools.md>), [tagged pointers](<https://devfeed.tech/topics/tagged-pointers.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [knowledge cutoff](<https://devfeed.tech/topics/knowledge-cutoff.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>)

Tags: [2023](<https://devfeed.tech/tags/2023.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-analysis](<https://devfeed.tech/tags/agentic-analysis.md>), [ai](<https://devfeed.tech/tags/ai.md>), [also](<https://devfeed.tech/tags/also.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [automated](<https://devfeed.tech/tags/automated.md>), [based](<https://devfeed.tech/tags/based.md>), [bug](<https://devfeed.tech/tags/bug.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [chrome](<https://devfeed.tech/tags/chrome.md>), [code](<https://devfeed.tech/tags/code.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [engine](<https://devfeed.tech/tags/engine.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [found](<https://devfeed.tech/tags/found.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [generative](<https://devfeed.tech/tags/generative.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [vs](<https://devfeed.tech/tags/vs.md>)

### AI overview

In a six-month production comparison on V8, BigSleep reported 45 actionable vulnerabilities and Fuzzilli 37, with about 25% overlap among reports. A separate experiment had BigSleep rediscover about 62% of selected historic Fuzzilli bugs, rising to roughly 70% with additional prompt and starting-point variations; the experiment excluded bugs that did not reproduce on a standard x64 debug+ASan build with permitted flags and may have used incorrect introducing commits. The results suggest the tools find many distinct bugs: BigSleep can reason through complex triggers and unusual values, while fuzzing can expose interactions across compiler optimizations that are difficult to identify by code review. Overlap varied by bug difficulty and component, and the study did not establish comparable cost per bug. The authors conclude that fuzzing and agentic code analysis remain complementary, while noting the comparison was limited to Fuzzilli, BigSleep, and V8.

### Source excerpt

Summary Project Zero compared two automated tools used by Google to find vulnerabilities in Chrome's JavaScript engine, V8, on a regular basis. Fuzzilli is a generative JavaScript engine fuzzer and BigSleep is an LLM-based bug finding system. In the past six months, BigSleep found more vulnerabilities than Fuzzilli (45 versus 37) with a 25% overlap in the specific bugs reported. Since this comparison methodology has a tendency to underestimate overlap, we also performed dedicated experiments to test theoretical overlap in vulnerabilities reported since 2023. These experiments estimated overlap at roughly 60%. Regardless of which value is accurate, a substantial portion of vulnerabilities were discoverable by only LLMs or only fuzzing. While it is extremely promising that LLMs have become able to find so many vulnerabilities so quickly, fuzzing and LLMs are still complementary approaches. We recommend vendors perform both fuzzing and agentic analysis of their code to maximize the number of vulnerabilities that get reported before they impact users.

## Pygame: A Primer on Game Programming in Python

DevFeed: [Pygame: A Primer on Game Programming in Python](<https://devfeed.tech/articles/pygame-a-primer-on-game-programming-in-python-95792.md>)

Original publisher: [Read original article](<https://realpython.com/pygame-a-primer/>)

Author: Jon Fincher

Published: 2026-10-22T14:00:00Z

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Game Development](<https://devfeed.tech/topics/game-development.md>), [Python](<https://devfeed.tech/topics/python.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [Image](<https://devfeed.tech/topics/image.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [import](<https://devfeed.tech/topics/import.md>), [pip](<https://devfeed.tech/topics/pip.md>), [memory handling](<https://devfeed.tech/topics/memory-handling.md>)

Tags: [game](<https://devfeed.tech/tags/game.md>), [games](<https://devfeed.tech/tags/games.md>), [multimedia](<https://devfeed.tech/tags/multimedia.md>), [programming](<https://devfeed.tech/tags/programming.md>), [pygame](<https://devfeed.tech/tags/pygame.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

This tutorial builds a keyboard-controlled obstacle-avoidance game with Pygame, showing how its game loop handles input, updates sprites, draws frames, and exits on a collision or window close. It introduces `Surface` and `Rect`, sprite groups for rendering, movement and collision checks, timed events for spawning enemies and clouds, and image-based sprites with transparent color keys. A `Clock.tick(30)` caps the frame rate so movement is more consistent across machines; without it, enemy speed depends on how quickly the loop runs. The tutorial also adds background music and sound effects through `pygame.mixer`, noting that Ogg is preferred over MP3 in the documentation and that audio should be tested on target platforms. It assumes basic Python knowledge and uses Python 3.13.

### Source excerpt

Learn how Pygame lets you build games and rich multimedia programs in Python: draw to the screen, detect collisions, and handle input.

## Localizing compliance at scale: achieving South Korea's ISMS certification

DevFeed: [Localizing compliance at scale: achieving South Korea's ISMS certification](<https://devfeed.tech/articles/localizing-compliance-at-scale-achieving-south-korea-s-isms-certification-95746.md>)

Original publisher: [Read original article](<https://blog.cloudflare.com/k-isms/>)

Author: Kabin Calan

Published: 2026-10-22T13:00:00Z

Content type: article

Language: en

Sources: [Cloudflare Blog](<https://devfeed.tech/sources/cloudflare-blog.md>)

Topics: [audit](<https://devfeed.tech/topics/audit.md>), [Cloudflare](<https://devfeed.tech/topics/cloudflare.md>), [Internationalization (i18n)](<https://devfeed.tech/topics/i18n.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>), [soc 2](<https://devfeed.tech/topics/soc-2.md>), [Cloudflare Workers](<https://devfeed.tech/topics/cloudflare-workers.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [about](<https://devfeed.tech/tags/about.md>), [audit](<https://devfeed.tech/tags/audit.md>), [certification](<https://devfeed.tech/tags/certification.md>), [cloudflare](<https://devfeed.tech/tags/cloudflare.md>), [compliance](<https://devfeed.tech/tags/compliance.md>), [consent](<https://devfeed.tech/tags/consent.md>), [controls](<https://devfeed.tech/tags/controls.md>), [dashboard](<https://devfeed.tech/tags/dashboard.md>), [global](<https://devfeed.tech/tags/global.md>), [korea](<https://devfeed.tech/tags/korea.md>), [learn](<https://devfeed.tech/tags/learn.md>), [privacy](<https://devfeed.tech/tags/privacy.md>), [program](<https://devfeed.tech/tags/program.md>), [scale](<https://devfeed.tech/tags/scale.md>), [security](<https://devfeed.tech/tags/security.md>), [sign](<https://devfeed.tech/tags/sign.md>), [sign-up](<https://devfeed.tech/tags/sign-up.md>), [social](<https://devfeed.tech/tags/social.md>), [south-korea](<https://devfeed.tech/tags/south-korea.md>), [up](<https://devfeed.tech/tags/up.md>), [user](<https://devfeed.tech/tags/user.md>)

### AI overview

Cloudflare obtained South Korea's ISMS certification after a KISA-appointed audit of 80 controls, with evidence reviewed against Korean legal and consent requirements. For Korean sign-ups, the form presents separate consent items, blocks account creation until required items are affirmatively accepted, and keeps marketing consent optional. Because Google, Apple, and GitHub sign-up bypass that form, Cloudflare disables those paths in South Korea. The Korean experience is selected using IP geolocation and the user's chosen country; the text cautions that IP location is an estimate and may miss residents traveling or using VPNs or carrier NAT. Auditors examined data flow diagrams, access controls across the data lifecycle, and consent wording. The certificate covers a service boundary defined by organizational operations, infrastructure, and data flows rather than a named product list; a product is in scope if delivered through that certified boundary. Certification lasts three years and requires annual audits.

### Source excerpt

Cloudflare has achieved South Korea's ISMS certification following an audit across 80 controls. Learn how we localized user consent flows, adapted social sign-up paths at the edge, and validated our global security program.

## Why does the compiler sometimes use ud2 and sometimes int 3 for code that shouldn't execute?

DevFeed: [Why does the compiler sometimes use ud2 and sometimes int 3 for code that shouldn't execute?](<https://devfeed.tech/articles/why-does-the-compiler-sometimes-use-ud2-and-sometimes-int-3-for-code-that-shouldn-t-execute-66608.md>)

Original publisher: [Read original article](<https://devblogs.microsoft.com/oldnewthing/20261006-00/?p=112757/>)

Author: Raymond Chen

Published: 2026-10-06T14:00:00Z

Content type: article

Language: en

Sources: [Raymond Chen](<https://devfeed.tech/sources/raymond-chen.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>)

Tags: [breakpoint](<https://devfeed.tech/tags/breakpoint.md>), [code](<https://devfeed.tech/tags/code.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [old-new-thing](<https://devfeed.tech/tags/old-new-thing.md>), [undefined-behavior](<https://devfeed.tech/tags/undefined-behavior.md>), [x86](<https://devfeed.tech/tags/x86.md>)

### AI overview

The article explains why x86 compilers use the one-byte int 3 instruction for padding where execution should never reach, and ud2 to mark code paths that should be unreachable because of undefined behavior. It suggests investigating logic flaws after ud2, and invalid or uninitialized function pointers or breakpoints after int 3.

### Source excerpt

It shouldn't execute, but for different reasons. The post Why does the compiler sometimes use <CODE>ud2</CODE> and sometimes <CODE>int 3</CODE> for code that shouldn't execute? appeared first on The Old New Thing.

## How developers can Build a Fixed-Share Inheritance Distribution Calculator

DevFeed: [How developers can Build a Fixed-Share Inheritance Distribution Calculator](<https://devfeed.tech/articles/how-developers-can-build-a-fixed-share-inheritance-distribution-calculator-50842.md>)

Original publisher: [Read original article](<https://www.sitepoint.com/how-developers-can-build-a-fixed-share-inheritance-distribution-calculator/>)

Author: SitePoint Team

Published: 2026-09-08T06:16:33Z

Content type: tutorial

Language: en

Sources: [SitePoint](<https://devfeed.tech/sources/sitepoint.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Python](<https://devfeed.tech/topics/python.md>), [Mathematics](<https://devfeed.tech/topics/mathematics.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [function](<https://devfeed.tech/topics/function.md>)

Tags: [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [code](<https://devfeed.tech/tags/code.md>), [conditionals](<https://devfeed.tech/tags/conditionals.md>), [developers](<https://devfeed.tech/tags/developers.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

A technical walkthrough of building a fixed-share inheritance distribution rules engine in Python. It models heirs, conditional blocking rules, exact fractional shares, and proportional reconciliation, using the Islamic Faraid system as a worked example while noting that the demonstration is not legal or religious guidance.

### Source excerpt

null Continue reading How developers can Build a Fixed-Share Inheritance Distribution Calculator on SitePoint.

## A field day for Gleam's language server

DevFeed: [A field day for Gleam's language server](<https://devfeed.tech/articles/a-field-day-for-gleam-s-language-server-51503.md>)

Original publisher: [Read original article](<https://gleam.run/news/a-field-day-for-gleams-language-server>)

Author: Louis Pilfold

Published: 2026-07-29T00:00:00Z

Content type: release

Language: en

Sources: [Gleam](<https://devfeed.tech/sources/gleam.md>)

Topics: [Release notes](<https://devfeed.tech/topics/release-notes.md>), [Developer Tools](<https://devfeed.tech/topics/developer-tools.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [modules](<https://devfeed.tech/topics/modules.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Erlang](<https://devfeed.tech/topics/erlang.md>)

Tags: [actions](<https://devfeed.tech/tags/actions.md>), [erlang](<https://devfeed.tech/tags/erlang.md>), [field](<https://devfeed.tech/tags/field.md>), [fields](<https://devfeed.tech/tags/fields.md>), [gleam](<https://devfeed.tech/tags/gleam.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [language](<https://devfeed.tech/tags/language.md>), [modules](<https://devfeed.tech/tags/modules.md>), [server](<https://devfeed.tech/tags/server.md>), [type](<https://devfeed.tech/tags/type.md>), [variables](<https://devfeed.tech/tags/variables.md>)

### AI overview

Gleam v1.18.0 adds broad language-server support for record-field navigation, references, and renaming across modules, plus renaming of type variables and modules, a pattern-match code action for function calls, and several other editing actions. The JavaScript compiler now reuses a single value for data structures whose instances are equivalent; tests report performance gains, especially in Lustre view functions. Compiler and formatter work using memory arenas made `gleam format` up to 13% faster on Lustre projects with 10% lower peak memory, and remains ongoing. The release also deprecates an ambiguous pipe form, with a code action to rewrite it explicitly; adds a subdirectory `path` option for Git dependencies; and accepts a read-only Hex API key through `HEXPM_READ_API_KEY` to access higher rate limits. Hex error messages, documentation URLs, and owner commands also received updates.

### Source excerpt

Gleam is a type safe and scalable language for the Erlang virtual machine and JavaScript runtimes. Today Gleam v1.18.0 has been published. Language server record field support Gleam's focus on static analysis and static types really helps with creating tooling, and that can be seen very clearly with Gleam's much-loved language server. All its features and capabilities can be seen in its documentation. One remaining missing part of it was full support for record fields, a problem now fixed! The language server now supports go-to-definition, find-references and rename for record fields. These work on the field declaration, on labelled arguments, on labelled patterns, on record updates and on record.field accesses, both within a module and across modules. For example: pub type Person { Person(name: String, age: Int) } pub fn main() { let lucy = Person(name: "Lucy", age: 10) lucy.name // ^ Go-to-definition jumps to the `name` field, and renaming it here // renames the field everywhere it is used. } Thank you Alistair Smith! People will be very happy for this one! Type variable renaming Similarly, the language server now permits renaming type variables in functions, types, and constants. For example: pub fn twice(value: a, f: fn(a) -> a) -> a { // ^ Rename to "anything" f(f(value)) } Produces: pub fn twice(value: anything, f: fn(anything) -> anything) -> anything { f(f(value)) } Thank you Surya Rose! Updating imports for renamed modules Another addition to the language server is support for renaming modules. When your text editor tells the language server that a Gleam file has been renamed, it will find all the uses of that module and update them for the new name. For example: import db_users pub fn main() -> db_users.User { db_users.new("username") } Renaming db_users.gleam to database/user.gleam would produce: import database/user pub fn main() -> user.User { user.new("username") } Thank you Surya Rose! Pattern match on value code action Flow control in Gleam is done w

## GitHub Actions: Smarter editing, clearer debugging, and a new case function

DevFeed: [GitHub Actions: Smarter editing, clearer debugging, and a new case function](<https://devfeed.tech/articles/github-actions-smarter-editing-clearer-debugging-and-a-new-case-function-72065.md>)

Original publisher: [Read original article](<https://github.blog/changelog/2026-01-29-github-actions-smarter-editing-clearer-debugging-and-a-new-case-function>)

Author: Allison

Published: 2026-01-29T17:37:43Z

Content type: release

Language: en

Sources: [GitHub Changelog](<https://devfeed.tech/sources/github-changelog.md>)

Topics: [GitHub Actions](<https://devfeed.tech/topics/github-actions.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [ide](<https://devfeed.tech/topics/ide.md>)

Tags: [actions](<https://devfeed.tech/tags/actions.md>), [authoring](<https://devfeed.tech/tags/authoring.md>), [autocomplete](<https://devfeed.tech/tags/autocomplete.md>), [condition](<https://devfeed.tech/tags/condition.md>), [conditionals](<https://devfeed.tech/tags/conditionals.md>), [context](<https://devfeed.tech/tags/context.md>), [control](<https://devfeed.tech/tags/control.md>), [cron](<https://devfeed.tech/tags/cron.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [editor](<https://devfeed.tech/tags/editor.md>), [emacs](<https://devfeed.tech/tags/emacs.md>), [extension](<https://devfeed.tech/tags/extension.md>), [function](<https://devfeed.tech/tags/function.md>), [github](<https://devfeed.tech/tags/github.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [logic](<https://devfeed.tech/tags/logic.md>), [troubleshoot](<https://devfeed.tech/tags/troubleshoot.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

GitHub Actions adds a `case` expression function for boolean-based conditional logic, including if/else and switch-style patterns. When an `if:` condition skips a job, its logs now show the original expression and an expanded version with runtime context values. Workflow authoring improvements bring context-aware completions, expression validation, and inline documentation to the web editor and other IDEs; a standalone language-service binary supports editors such as NeoVim, Emacs, and Sublime. Editing `action.yml` files also gains metadata autocomplete, action-type-specific `runs` suggestions, schema and expression validation, and scaffolding snippets. Validation catches text outside `${{ }}` in `if` conditions, which can make them always-truthy strings, and invalid `format` strings; trailing newlines are trimmed automatically. The excerpt does not provide usage details or examples for the new function.

### Source excerpt

We've shipped several improvements to GitHub Actions that make it easier to write, validate, and troubleshoot workflow logic, especially when you rely on if: conditionals to control what runs. Here...

## Formalising external APIs

DevFeed: [Formalising external APIs](<https://devfeed.tech/articles/formalising-external-apis-51504.md>)

Original publisher: [Read original article](<https://gleam.run/news/formalising-external-apis>)

Author: Louis Pilfold

Published: 2025-10-19T00:00:00Z

Content type: release

Language: en

Sources: [Gleam](<https://devfeed.tech/sources/gleam.md>)

Topics: [Tool](<https://devfeed.tech/topics/tool.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [adapter pattern](<https://devfeed.tech/topics/adapter-pattern.md>), [Erlang](<https://devfeed.tech/topics/erlang.md>), [code beautification](<https://devfeed.tech/topics/code-beautification.md>), [import](<https://devfeed.tech/topics/import.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Sequences](<https://devfeed.tech/topics/sequences.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [identifier](<https://devfeed.tech/topics/identifier.md>), [Exception handling](<https://devfeed.tech/topics/exception-handling.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [beam](<https://devfeed.tech/tags/beam.md>), [data](<https://devfeed.tech/tags/data.md>), [data-types](<https://devfeed.tech/tags/data-types.md>), [ecosystem](<https://devfeed.tech/tags/ecosystem.md>), [ecosystems](<https://devfeed.tech/tags/ecosystems.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [erlang](<https://devfeed.tech/tags/erlang.md>), [external](<https://devfeed.tech/tags/external.md>), [interface](<https://devfeed.tech/tags/interface.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [performance](<https://devfeed.tech/tags/performance.md>), [wrapper](<https://devfeed.tech/tags/wrapper.md>)

### AI overview

Gleam v1.13.0 adds a documented guide for externals and a dedicated JavaScript API for constructing and inspecting Gleam data. Existing JavaScript externals will need to migrate, with tooling and team help planned. The compiler also prunes redundant bit-array checks and warns about impossible bit patterns, unused recursive arguments, and inefficient list-length emptiness checks. Build output now reports dependency changes to support auditing locked versions. Many language-server improvements add or refine code actions, including extracting functions, expanding and collapsing pattern matches, and generating functions across modules; extraction uses a placeholder name because of an LSP limitation. Other changes improve type names in generated documentation and editor actions, syntax diagnostics, and formatter behavior.

### Source excerpt

Gleam is a type-safe and scalable language for the Erlang virtual machine and JavaScript runtimes. Today Gleam v1.13.0 has been published. Let's go over all the highlights now. External API for Gleam data One of Gleam's strengths is that it is part of the BEAM and JavaScript ecosystems, enabling Gleam programs to take advantage of code written in Erlang, Elixir, JavaScript, and more. This is a large part of how Gleam was able to become a practical production-ready language so quickly, by not restricting Gleam programmers to just the comparatively young Gleam package ecosystem. A function written in one of these other languages can be imported into a Gleam module as an "external function", and then called without any additional performance overhead. @external(erlang, "moon_base", "launch_spaceship") pub fn lift_off(countdown: Int) -> Result(Spaceship, LaunchError) Here the Erlang function launch_spaceship from the module moon_base is being imported. One restriction to external functions is that they will need to return data types that Gleam can understand. Gleam's "external type" feature lets the programmer refer to types defined in other languages, but if the programmer wants to be able to directly construct and pattern match data from external functions it will need to be in a format compatible with Gleam data types. Often a programmer will write a small wrapper function in the external language to convert the data, and also to make the interface adhere to Gleam patterns and conventions. -module(moon_base). -export([launch_spaceship/1]). launch_spaceship(Countdown) -> try Spaceship = launch_control:launch_spaceship(Countdown), {ok, Spaceship} catch error:no_fuel -> {error, no_fuel}; error:bad_weather -> {error, bad_weather} end. This launch_spaceship Erlang function wraps the function from the launch_control module, converting the exception-based API into a Result type, the Erlang representation of Gleam's Ok and Error variants. One thing that a Gleam programmer ma

## Using if-else Conditionals in a Makefile

DevFeed: [Using if-else Conditionals in a Makefile](<https://devfeed.tech/articles/using-if-else-conditionals-in-a-makefile-4515.md>)

Original publisher: [Read original article](<https://feeds.feedblitz.com/~/919796387/0/baeldung/linux~Using-ifelse-Conditionals-in-a-Makefile>)

Author: baeldung

Published: 2025-06-06T09:36:00Z

Content type: tutorial

Language: en

Sources: [Baeldung - Linux](<https://devfeed.tech/sources/baeldung-linux.md>)

Topics: [make](<https://devfeed.tech/topics/make.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Bash](<https://devfeed.tech/topics/bash.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [awk](<https://devfeed.tech/tags/awk.md>), [bash](<https://devfeed.tech/tags/bash.md>), [build](<https://devfeed.tech/tags/build.md>), [building](<https://devfeed.tech/tags/building.md>), [building-make-popular](<https://devfeed.tech/tags/building-make-popular.md>), [cc](<https://devfeed.tech/tags/cc.md>), [command](<https://devfeed.tech/tags/command.md>), [commands](<https://devfeed.tech/tags/commands.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [conditional](<https://devfeed.tech/tags/conditional.md>), [conditionals](<https://devfeed.tech/tags/conditionals.md>), [debug](<https://devfeed.tech/tags/debug.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [directives](<https://devfeed.tech/tags/directives.md>), [disk-space](<https://devfeed.tech/tags/disk-space.md>), [echo](<https://devfeed.tech/tags/echo.md>), [endif](<https://devfeed.tech/tags/endif.md>), [environment](<https://devfeed.tech/tags/environment.md>), [error](<https://devfeed.tech/tags/error.md>), [file](<https://devfeed.tech/tags/file.md>), [linux](<https://devfeed.tech/tags/linux.md>), [make](<https://devfeed.tech/tags/make.md>), [popular](<https://devfeed.tech/tags/popular.md>), [scripting](<https://devfeed.tech/tags/scripting.md>), [shell](<https://devfeed.tech/tags/shell.md>)

### AI overview

Makefile conditionals use directives such as `ifeq` and `ifneq` to compare strings, and `ifdef` and `ifndef` to check whether variables are defined. The examples select compiler flags, provide a default compiler, and choose OS-specific behavior. For file checks inside a recipe, the article uses a shell `if`; Make's `$(if ...)` function supports inline conditional values. It also demonstrates checking disk space with `$(shell ...)` and stopping with `$(error ...)`. Recipe lines generally run in separate shell instances, so shell variables do not carry across lines.

### Source excerpt

Learn how to use if-else conditional statements inside of Makefiles. The post Using if-else Conditionals in a Makefile first appeared on Baeldung on Linux. Related Stories How to Identify the Package Manager of a Linux System Background Jobs in a Loop in Bash Executing Commands in Gnuplot through Shell Script

## UI State, Callbacks and Equality Pitfalls

DevFeed: [UI State, Callbacks and Equality Pitfalls](<https://devfeed.tech/articles/ui-state-callbacks-and-equality-pitfalls-25875.md>)

Original publisher: [Read original article](<http://lordraydenmk.github.io//2024/ui-state-callbacks/>)

Author: Stojan Anastasov

Published: 2024-11-30T00:00:00Z

Content type: article

Language: en

Sources: [Stojan Anastasov's blog](<https://devfeed.tech/sources/stojan-anastasov-s-blog.md>)

Topics: [state-management](<https://devfeed.tech/topics/state-management.md>), [User Interfaces](<https://devfeed.tech/topics/user-interfaces.md>), [equals](<https://devfeed.tech/topics/equals.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>)

Tags: [actions](<https://devfeed.tech/tags/actions.md>), [android](<https://devfeed.tech/tags/android.md>), [data-class](<https://devfeed.tech/tags/data-class.md>), [example](<https://devfeed.tech/tags/example.md>), [function](<https://devfeed.tech/tags/function.md>), [functions](<https://devfeed.tech/tags/functions.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [pitfalls](<https://devfeed.tech/tags/pitfalls.md>), [sealed](<https://devfeed.tech/tags/sealed.md>), [sealed-class](<https://devfeed.tech/tags/sealed-class.md>), [state](<https://devfeed.tech/tags/state.md>), [ui](<https://devfeed.tech/tags/ui.md>), [view](<https://devfeed.tech/tags/view.md>), [viewmodel](<https://devfeed.tech/tags/viewmodel.md>)

### AI overview

In Kotlin data classes, equality includes each constructor property, but lambdas compare by reference. Recreating a callback for the same superhero therefore makes otherwise equivalent view entities unequal, potentially triggering unnecessary list updates in RecyclerView or Compose lazy lists. The post considers custom equality or reusing callback instances, and moving the favorite check into the view, but describes these as error prone or a poor fit as logic grows. Its preferred approach keeps the decision in the ViewModel/Presenter and stores a data-only sealed action such as Add(id) or Remove(id) in the entity. The view passes that action back for execution, preserving simple view logic while avoiding callback-based equality.

### Source excerpt

Yesterday a friend asked me to review his blog post on Function Properties in Data Classes are Code Smells. We then discussed how we would solve the issue in the context of UI state and callbacks. And I thought it might be useful to write it in form of a blog post. An example To better explain the problem, I'll start with a sample app I'm maintaining. It shows a list of superheroes from the Marvel API. See the screenshot below. Currently the UI state is modeled like: data class SuperheroViewEntity( val id: Long, val name: String, val imageUrl: HttpUrl ) Content( val superheroes: List<SuperheroViewEntity>, val copyright: String, ) // some states omitted for brevity A Naive Solution Let's say we have a new requirement, we want to add a favorite button to each superhero so we can keep track of our favorite superheroes. To do that we will introduce some functions: // ViewModel/Presenter fun onAddToFavorites(superheroId: Long) = TODO() fun onRemoveFromFavorites(superheroId: Long) = TODO() These functions can be part of the ViewModel/Presenter that delegates to a repository to store the IDs. Note: In this example, the ViewModel/Presenter use a single function per action the view can take. The technique described here also works with a single function + a sealed class for individual actions. To achieve this we might be tempted to update our SuperheroViewEntity to include: data class SuperheroViewEntity( val id: Long, val name: String, val imageUrl: HttpUrl, val onFavoriteClicked: () -> Unit ) // ViewModel fun Superhero.toViewEntity() = SuperheroViewEntity( id, name, imageUrl, if (favorite) { onRemoveFromFavorites(id) } else { onAddToFavorites(id) } ) // View layer Modifier.clickable { entity.onFavoriteClicked() } However this approach has some significant drawbacks. Functions in Kotlin are equal only if they are the same reference. val fa = { println(1) } val fb = { println(1) } println(fa == fb) // false, does the same job, but different reference val fc = fa println(fc =

## TypeScript enums and falsy values

DevFeed: [TypeScript enums and falsy values](<https://devfeed.tech/articles/typescript-enums-and-falsy-values-52575.md>)

Original publisher: [Read original article](<http://www.jackfranklin.co.uk/blog/typescript-enums-0-values/>)

Published: 2024-11-17T00:00:00Z

Content type: article

Language: en

Sources: [Jack Franklin](<https://devfeed.tech/sources/jack-franklin.md>)

Topics: [TypeScript](<https://devfeed.tech/topics/typescript.md>), [enum](<https://devfeed.tech/topics/enum.md>), [union types](<https://devfeed.tech/topics/union-types.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Null-Safety](<https://devfeed.tech/topics/null-safety.md>), [if statement](<https://devfeed.tech/topics/if-statement.md>)

Tags: [boolean](<https://devfeed.tech/tags/boolean.md>), [bug](<https://devfeed.tech/tags/bug.md>), [code](<https://devfeed.tech/tags/code.md>), [condition](<https://devfeed.tech/tags/condition.md>), [conditional](<https://devfeed.tech/tags/conditional.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [enum](<https://devfeed.tech/tags/enum.md>), [enums](<https://devfeed.tech/tags/enums.md>), [function](<https://devfeed.tech/tags/function.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [members](<https://devfeed.tech/tags/members.md>), [null](<https://devfeed.tech/tags/null.md>), [number](<https://devfeed.tech/tags/number.md>), [return](<https://devfeed.tech/tags/return.md>), [status](<https://devfeed.tech/tags/status.md>), [string](<https://devfeed.tech/tags/string.md>), [typescript](<https://devfeed.tech/tags/typescript.md>), [value](<https://devfeed.tech/tags/value.md>), [values](<https://devfeed.tech/tags/values.md>)

### AI overview

A numeric TypeScript enum starts at 0 by default, and JavaScript treats 0 as falsy. When a function returns an enum value or null, `if (status)` therefore mistakes the first enum member for "not logged in." The text recommends checking `status !== null`, or assigning enum members nonzero numeric values or nonempty strings so truthiness checks do not reject a valid status. It also notes that the issue can pass TypeScript compilation and mentions the TypeScript ESLint `strict-boolean-expressions` rule as a possible aid.

### Source excerpt

I recently lost an evening to debugging a subtle issue which highlights a potential pitfall in the interaction between TypeScript enums and "falsy" values in JavaScript. Let's look at a scenario that illustrates this problem: Spot the Bug Consider the following code where a function returns either an enum value or null depending on whether a user is logged in: const enum Status { Inactive, Active, Pending, } function getUserStatus(user?: User): Status | null { if (!user) { // No user is logged in. return null } return user.status() } function checkUserStatus(user?: User): void { const status = getUserStatus(userId) if (status) { console.log('User has a valid status:', status) } else { console.log('The user is not logged in.') } } What's the Issue? JavaScript has a concept of truthy and falsy values. In conditional statements, values that are considered falsy are treated as false. The list of falsy values in JavaScript include: false 0 "" (empty string) null undefined NaN This means that if(0) {} is always false in JavaScript. Now we can look at the default values assigned to enum members in TypeScript. As the TypeScript documentation states, when initializing enum values, the default values are numeric and start from 0. These two enums are equivalent: const enum Status { Inactive = 0, Active = 1, Pending = 2, } const enum Status { Inactive, Active, Pending, } This means that if an enum member is assigned the value 0, it will behave like false in any condition where truthiness is evaluated rather than explicitly checking for the null value. Solving with explicit checks To avoid this bug, explicitly check for null instead of relying on truthy checks: function checkUserStatus(user?: User): void { const status = getUserStatus(user) if (status !== null) { console.log('User has a valid status:', status) } else { console.log('The user is not logged in.') } } Solving with explicit enum values Alternatively, because each number in JavaScript that is not 0 is considered truth

## Conditionally Disabling Code with Comptime in Zig

DevFeed: [Conditionally Disabling Code with Comptime in Zig](<https://devfeed.tech/articles/conditionally-disabling-code-with-comptime-in-zig-51459.md>)

Original publisher: [Read original article](<https://mitchellh.com/writing/zig-comptime-conditional-disable>)

Published: 2024-09-12T00:00:00Z

Content type: tutorial

Language: en

Sources: [Mitchell Hashimoto](<https://devfeed.tech/sources/mitchell-hashimoto.md>)

Topics: [Zig](<https://devfeed.tech/topics/zig.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [conditionals](<https://devfeed.tech/tags/conditionals.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [development](<https://devfeed.tech/tags/development.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [linux](<https://devfeed.tech/tags/linux.md>), [macos](<https://devfeed.tech/tags/macos.md>), [zig](<https://devfeed.tech/tags/zig.md>)

### AI overview

A tutorial on using Zig's comptime feature to conditionally disable code at compile time. It explains how comptime runs standard Zig code during compilation and discusses use cases such as platform-specific implementations, debugging code, and build configuration.

### Source excerpt

Conditionally Disabling Code with Comptime in Zig Zig has a very powerful feature called comptime. Comptime lets you run Zig code at compile time. This isn't a special macro language or AST manipulation; it is just standard Zig code that runs at compile time. The only real limitation is that comptime code can't have side effects (no syscalls, no IO, etc.). I admit that when I first started looking into Zig, I thought this was a gimmick.

## Inline conditionals in CSS, now?

DevFeed: [Inline conditionals in CSS, now?](<https://devfeed.tech/articles/inline-conditionals-in-css-now-52157.md>)

Original publisher: [Read original article](<https://lea.verou.me/blog/2024/css-conditionals-now/>)

Author: Lea Verou

Published: 2024-06-21T00:00:00Z

Content type: opinion

Language: en

Sources: [Lea Verou's blog](<https://devfeed.tech/sources/lea-verou-s-blog.md>)

Topics: [conditionals](<https://devfeed.tech/topics/conditionals.md>), [CSS](<https://devfeed.tech/topics/css.md>), [Web platform](<https://devfeed.tech/topics/web-platform.md>), [web-standards](<https://devfeed.tech/topics/web-standards.md>), [abstraction](<https://devfeed.tech/topics/abstraction.md>), [Vue.js](<https://devfeed.tech/topics/vue.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [conditionals](<https://devfeed.tech/tags/conditionals.md>), [css](<https://devfeed.tech/tags/css.md>), [css-variables](<https://devfeed.tech/tags/css-variables.md>), [css-wg](<https://devfeed.tech/tags/css-wg.md>), [developers](<https://devfeed.tech/tags/developers.md>), [vue](<https://devfeed.tech/tags/vue.md>), [web-components](<https://devfeed.tech/tags/web-components.md>), [web-platform](<https://devfeed.tech/tags/web-platform.md>)

### AI overview

The article examines the gap between the CSS Working Group's planned if() function and current browser support. It presents custom-property hacks as interim options and argues that production decisions should prioritize user needs over developer convenience, drawing on Web Platform Design Principles and the Priority of Constituencies.

### Source excerpt

The CSS WG resolved to add if() to CSS, but that won't be in browsers for a while. What are our options in the meantime? A couple days ago, I posted about the recent CSS WG resolution to add an if() function to CSS. Great as it may be, this is still a long way off, two years if everything goes super smoothly, more if not. So what can you do when you need conditionals right now? You may be pleased to find that you're not completely out of luck. There is a series of brilliant, horrible hacks that enable you to expose the kinds of higher level custom properties that conditionals typically enable. Using hacks in production?! The instinctive reaction many developers have when seeing hacks like these is "Nice hack, but can't possibly ever use this in production". This sounds reasonable on the surface (keeping the codebase maintainable is a worthy goal!) but when examined deeply, it reflects the wrong order of priorities, prioritizing developer convenience over user convenience. The TAG maintains a Web Platform Design Principles document 1 that everyone designing APIs for the web platform is supposed to read and follow. I'm a strong believer in having published Design Principles, for any product2. They help stay on track, and remember what the big picture vision is, which is otherwise easy to lose sight of in the day to day minutiae. One of the core principles in the document is the Priority of Constituencies. The core of it is: User needs come before the needs of web page authors, which come before the needs of user agent implementors, which come before the needs of specification writers, which come before theoretical purity. Obviously in most projects there are far fewer stakeholders than for the whole web platform, but the spirit of the principle still applies: the higher the abstraction, the higher priority the user needs. Or, in other words, consumers above producers. For a more relatable example, in a web app using a framework like e.g. Vue and several Vue components

## Inline conditionals in CSS?

DevFeed: [Inline conditionals in CSS?](<https://devfeed.tech/articles/inline-conditionals-in-css-52158.md>)

Original publisher: [Read original article](<https://lea.verou.me/blog/2024/css-conditionals/>)

Author: Lea Verou

Published: 2024-06-18T00:00:00Z

Content type: article

Language: en

Sources: [Lea Verou's blog](<https://devfeed.tech/sources/lea-verou-s-blog.md>)

Topics: [CSS](<https://devfeed.tech/topics/css.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Web Development](<https://devfeed.tech/topics/web-development.md>), [browser](<https://devfeed.tech/topics/browser.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [conditionals](<https://devfeed.tech/tags/conditionals.md>), [css](<https://devfeed.tech/tags/css.md>), [css-variables](<https://devfeed.tech/tags/css-variables.md>), [css-wg](<https://devfeed.tech/tags/css-wg.md>), [developers](<https://devfeed.tech/tags/developers.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [roadmaps](<https://devfeed.tech/tags/roadmaps.md>), [web-components](<https://devfeed.tech/tags/web-components.md>), [web-standards](<https://devfeed.tech/tags/web-standards.md>)

### AI overview

The article discusses the CSS Working Group's consensus to add an inline if() conditional syntax to CSS. It explains the proposal's motivation, relationship to style queries, and path through earlier rejected proposals.

### Source excerpt

Last week, the CSS WG resolved to add an inline if() to CSS. But what does that mean, and why is it exciting? Last week, we had a CSS WG face-to-face meeting in A Coruña, Spain. There is one resolution from that meeting that I'm particularly excited about: the consensus to add an inline if() to CSS. While I was not the first to propose an inline conditional syntax, I did try and scope down the various nonterminating discussions into an MVP that can actually be implemented quickly, discussed ideas with implemenators, and eventually published a concrete proposal and pushed for group resolution. Quite poetically, the relevant discussion occurred on my birthday, so in a way, I got if() as the most unique birthday present ever. 😀 This also comes to show that proposals being rejected is not the end-all for a given feature. It is in fact quite common for features to be rejected for several times before they are accepted: CSS Nesting, :has(), container queries were all simply the last iteration in a series of rejected proposals. if() itself was apparently rejected in 2018 with very similar syntax to what I proposed. What was the difference? Style queries had already shipped, and we could simply reference the same syntax for conditions (plus media() and supports() from Tab's @when proposal) whereas in the 2018 proposal how conditions would work was largely undefined. I posted about this on a variety of social media, and the response by developers has been overwhelmingly positive: Twitter LinkedIn Mastodon I even had friends from big companies writing to tell me their internal Slacks blew up about it. This proves what I've always suspected, and was part of the case I made to the CSS WG: that this is a huge pain point. Hopefully the amount and intensity of positive reactions will help browsers prioritize this feature and add it to their roadmaps earlier rather than later. Across all these platforms, besides the "I can't wait for this to ship!" sentiment being most common, ther

## SudoLang: A Powerful Pseudocode Programming Language for LLMs

DevFeed: [SudoLang: A Powerful Pseudocode Programming Language for LLMs](<https://devfeed.tech/articles/sudolang-a-powerful-pseudocode-programming-language-for-llms-20715.md>)

Original publisher: [Read original article](<https://medium.com/javascript-scene/sudolang-a-powerful-pseudocode-programming-language-for-llms-d64d42aa719b?source=rss----c0aeac5284ad---4>)

Author: Eric Elliott

Published: 2023-04-01T02:15:41Z

Content type: article

Language: en

Sources: [Eric Elliot](<https://devfeed.tech/sources/eric-elliot.md>)

Topics: [sudolang](<https://devfeed.tech/topics/sudolang.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Transpilers](<https://devfeed.tech/topics/transpilers.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Syntax Highlighting](<https://devfeed.tech/topics/syntax-highlighting.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [chatgpt](<https://devfeed.tech/tags/chatgpt.md>), [language](<https://devfeed.tech/tags/language.md>), [llms](<https://devfeed.tech/tags/llms.md>), [nlp](<https://devfeed.tech/tags/nlp.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [pseudocode](<https://devfeed.tech/tags/pseudocode.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [sudolang](<https://devfeed.tech/tags/sudolang.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

SudoLang uses natural-language instructions alongside programming constructs to let an LLM interpret, build, and interactively refine programs. The excerpt describes variables, conditionals, loops, logical operators, function composition with `|>`, ranges, destructuring, pattern matching, and constraints; examples show concise pseudocode being transpiled to JavaScript and a teaching program using inferred functions and scoped flow control. The author says GPT-4 handles these detailed instructions and examples much better than GPT-3.5, which does not follow the teaching program reliably. The language can also serve as a structured way to clarify requirements before generating code. LLM outputs remain prone to errors and hallucinations and should be checked. The excerpt recommends pasting the specification into ChatGPT with GPT-4 or later to try it.

### Source excerpt

Pseudocode is a fantastic way to sketch programs using informal, natural language, without worrying about specific syntax. It's like sketching your thoughts before diving into the nitty-gritty of coding. It's useful for brainstorming and communicating ideas with others. I have been using pseudocode to express ideas to Large Language Models (LLMs) since GPT-3 was announced in mid 2020. However, up until GPT-4 was released, it didn't work extremely well. It sometimes worked, but I threw away most completions on GPT-3 and GPT-3.5. Even so, LLMs were already extremely useful in that state. In a 2022 study, GitHub found that Copilot shaved 55% of the time off a project task assigned to 95 people: 45 using Copilot, and the rest without. In other words, even before LLM pseudocode languages like SudoLang, LLMs were already making a huge impact on developer productivity. But GPT-4 raises the bar. Not a little bit, but a lot. First, let's address the obvious. GPT-4 is: 40% less likely to deliver an incorrect response. (But still prone to errors and hallucinations. Be sure to check its output!) Multi-modal and can interact with both text and images. (I haven't had the chance to test this, yet.) Sweeping intelligence and training improvements. (This may be an understatement. The improvement is astonishing.) Much longer context available. (It can help you build much larger programs!) GPT-4 scores significantly better on a broad range of human level knowledge and intelligence assessment tests, including the Bar, LSAT, SAT, GRE, and AP placement tests. (Hot tip: GPT-4 is still not a lawyer even if it can pass the Bar. It will still sometimes hallucinate facts that aren't true. Please don't let it get you into legal trouble!) Source: GPT-4 Technical Report The really interesting upshot of all this is that GPT-4 now has the ability to follow detailed, step by step instructions, even through complex abstractions and long chains of function compositions. I've been playing with a lot o

## Clojure Sound - 4 - Ctrl-Left-Pedal

DevFeed: [Clojure Sound - 4 - Ctrl-Left-Pedal](<https://devfeed.tech/articles/clojure-sound-4-ctrl-left-pedal-20722.md>)

Original publisher: [Read original article](<http://dragan.rocks/articles/22/Clojure-Sound-4-Ctrl-Left-Pedal>)

Published: 2022-07-13T18:45:00Z

Content type: tutorial

Language: en

Sources: [Dragan Djuric](<https://devfeed.tech/sources/dragan-djuric.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [input](<https://devfeed.tech/topics/input.md>), [Decoding](<https://devfeed.tech/topics/decoding.md>), [IO](<https://devfeed.tech/topics/io.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>)

Tags: [alsa](<https://devfeed.tech/tags/alsa.md>), [audio](<https://devfeed.tech/tags/audio.md>), [audio-player](<https://devfeed.tech/tags/audio-player.md>), [buttons](<https://devfeed.tech/tags/buttons.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [controller](<https://devfeed.tech/tags/controller.md>), [midi](<https://devfeed.tech/tags/midi.md>), [music](<https://devfeed.tech/tags/music.md>), [recording](<https://devfeed.tech/tags/recording.md>), [sound](<https://devfeed.tech/tags/sound.md>), [usb](<https://devfeed.tech/tags/usb.md>)

### AI overview

The article demonstrates using Clojure Sound to control a WAV clip with MIDI hardware. A Faderfox MX12's controller 37 starts or stops playback according to its value; stopping preserves the current position, and seeking to frame 0 rewinds. A Roland FC-300 connected through a USB sound card sends general-purpose controls 80 and 81, which the example maps to separate start and stop actions in Clojure. The pedal also emits unexplained empty channel-14 messages about every 200 ms. The author notes that changing the pedal's assignments is cumbersome, and sending control changes back does not update the controllers' LEDs, leaving their displayed states out of sync when either device controls playback.

### Source excerpt

In the last article we managed to connect a MIDI controller and receive updates whenever something happens to its knobs and buttons. So what? As it is, nothing. Printing out messages is not of much use, beyond perhaps getting informed about how these messages look like, and what kind of data they typically contain. On another thought, exactly that is often valuable, because how else can we debug what's happening and learn how to use these devices. They typically don't come with terrific manuals. Luckily, basic use revolves around receiving one of a few kind of standard messages, that typically contain only a handful of bytes, more or less conforming to the MIDI standard, so it's up to us to assign the meaning according to our use case. If we care to read the standard, we could try to pick the closest meaning in our application, but if that's not possible, or practical, well... you live only once. Let's celebrate creativity and be silly. What I would like Cool, so, at first, I have an audio recording of a few chords interposed with some talk and noise, just a single wav file. I'd like to discover how to play only selected segments (i.e. the chords I'm interested in guessing), with arbitrary repetitions. The purpose of this is not to create a perfect looper or learning device, at least not yet. At first, I'm just interested in creating the crudest audio player, and discovering how to connect the player to react to the input from the MIDI controller that we connected last week. After that, it would be nice to see whether the foot pedal works in the same way, or it needs more poking. As we discovered last week, the more modern Faderfox MX12 connects through USB and is listed as one of the connected MIDI devices. The Roland FC-300 foot pedal, does not support USB, so I connect it via a 5-pin MIDI cable to my USB sound card. It will probably be displayed as a MIDI in/out of that sound card (more on that later). MIDI Controller (hands) The usual imports: (ns my-midi) (requir

[Next page](<https://devfeed.tech/topics/conditionals.md?cursor=WyIyMDIyLTA3LTEzVDE4OjQ1OjAwKzAwOjAwIiwgIjAwY2I4ZTQyLWUyZmUtNDM2NS1iZGMwLTk3NzAyZjE1ZDhhNSJd>)