Login

Recent searches

No recent searches

Search options

Not available on mastodon.xyz.
mastodon.xyz is one of the many independent Mastodon servers you can use to participate in the fediverse.
A Mastodon instance, open to everyone, but mainly English and French speaking.

Administered by:

Server stats:

745
active users

mastodon.xyz: AboutProfiles directoryPrivacy policy

Mastodon: AboutGet the appKeyboard shortcutsView source codev4.3.4

#exceptions

0 posts0 participants0 posts today
Public
Harald

"Checked" #exceptions in different languages: a checked exception is a "another" return value of a function declared in its signature.

- C (afair): special values
- #Rust: return type Result<R, E>
- #Java throws SuchAndSuchException
- #TypeScript: return type Stuff | Error

Checked exceptions are debated a lot, but maybe stop calling them exceptions. Rust does it nearly right. See more in my latest blog musings:

miamao.de/blog/2025-06/30.Chec

miamao.deHaralds Blog — Checked Exceptions are not Exceptional
#programming#checked_exceptions
Public *
Nonilex

For the third consecutive year, #Louisiana lawmakers rejected a bill that would have allowed young victims of #rape to get an #abortion.

In an emotional & #religious-laced legislative committee meeting legislators objected to adding rape, in cases where the girl is under the age of 17 & impregnated as a result of the sexual offense, to the narrow list of #exceptions for one of the strictest #AbortionBans in the country.

#law #FarRight #MaleSupremacy
apnews.com/article/louisiana-a

AP News · Louisiana lawmakers reject proposed exception to near-total abortion banBy Sara Cline
Public
WIST Quotations

A quotation from Nassim Nicholas Taleb

I don’t particularly care about the usual. If you want to get an idea of a friend’s temperament, ethics, and personal elegance, you need to look at him under the tests of severe circumstances, not under the regular rosy glow of daily life. Can you assess the danger a criminal poses by examining only what he does on an ordinary day? Can we understand health without considering wild diseases and epidemics? Indeed the normal is often irrelevant.

Nassim Nicholas Taleb (b. 1960) Lebanese-American essayist, statistician, risk analyst, aphorist
The Black Swan, Introduction (2007)

Sourcing, notes: wist.info/taleb-nassim-nichola…

#quote#quotes#quotation
Public
洪 民憙 (Hong Minhee)

Revisiting Java's Checked Exceptions: An Underappreciated Type Safety Feature

hackers.pub/@hongminhee/2025/r

Hackers' Pub · Revisiting Java's Checked Exceptions: An Underappreciated Type Safety FeatureDespite their bad reputation in the Java community, checked exceptions provide superior type safety comparable to Rust's Result<T, E> or Haskell's Either—we've been dismissing one of Java's best features all along.Introduction Few features in Java have been as consistently criticized as checked exceptions. Modern Java libraries and frameworks often go to great lengths to avoid them. Newer JVM languages like Kotlin have abandoned them entirely. Many experienced Java developers consider them a design mistake. But what if this conventional wisdom is wrong? What if checked exceptions represent one of Java's most forward-thinking features? In this post, I'll argue that Java's checked exceptions were ahead of their time, offering many of the same type safety benefits that are now celebrated in languages like Rust and Haskell. Rather than abandoning this feature, we should consider how to improve it to work better with modern Java's features.Understanding Java's Exception Handling Model To set the stage, let's review how Java's exception system works:<Unchecked exceptions (subclasses of RuntimeException or Error): These don't need to be declared or caught. They typically represent programming errors (NullPointerException, IndexOutOfBoundsException) or unrecoverable conditions (OutOfMemoryError).<Checked exceptions (subclasses of Exception but not RuntimeException): These must either be caught with try/catch blocks or declared in the method signature with throws. They represent recoverable conditions that are outside the normal flow of execution (IOException, SQLException).<Here's how this works in practice:// Checked exception - compiler forces you to handle or declare itpublic void readFile(String path) throws IOException { Files.readAllLines(Path.of(path));}// Unchecked exception - no compiler enforcementpublic void processArray(int[] array) { int value = array[array.length + 1]; // May throw ArrayIndexOutOfBoundsException}<The Type Safety Argument for Checked Exceptions At their core, checked exceptions are a way of encoding potential failure modes into the type system via method signatures. This makes certain failure cases part of the API contract, forcing client code to explicitly handle these cases. Consider this method signature:public byte[] readFileContents(String filePath) throws IOException<The throws IOException clause tells us something critical: this method might fail in ways related to IO operations. The compiler ensures you can't simply ignore this fact. You must either:Handle the exception with a try-catch blockPropagate it by declaring it in your own method signature<This type-level representation of potential failures aligns perfectly with principles of modern type-safe programming.Automatic Propagation: A Hidden Advantage One often overlooked advantage of Java's checked exceptions is their automatic propagation. Once you declare a method as throws IOException, any exception that occurs is automatically propagated to the caller without additional syntax. Compare this with Rust, where you must use the ? operator every time you call a function that returns a Result:// Rust requires explicit propagation with ? for each callfn read_and_process(path: &str) -> Result<(), std::io::Error> { let content = std::fs::read_to_string(path)?; process_content(&content)?; Ok(())}// Java automatically propagates exceptions once declaredvoid readAndProcess(String path) throws IOException { String content = Files.readString(Path.of(path)); processContent(content); // If this throws IOException, it's automatically propagated}<In complex methods with many potential failure points, Java's approach leads to cleaner code by eliminating the need for repetitive error propagation markers.Modern Parallels: Result Types in Rust and Haskell The approach of encoding failure possibilities in the type system has been adopted by many modern languages, most notably Rust with its Result<T, E> type and Haskell with its Either a b type. In Rust:fn read_file_contents(file_path: &str) -> Result<Vec<u8>, std::io::Error> { std::fs::read(file_path)}<When calling this function, you can't just ignore the potential for errors—you need to handle both the success case and the error case, often using the ? operator or pattern matching. In Haskell:readFileContents :: FilePath -> IO (Either IOException ByteString)readFileContents path = try $ BS.readFile path<Again, the caller must explicitly deal with both possible outcomes. This is fundamentally the same insight that motivated Java's checked exceptions: make failure handling explicit in the type system.Valid Criticisms of Checked Exceptions If checked exceptions are conceptually similar to these widely-praised error handling mechanisms, why have they fallen out of favor? There are several legitimate criticisms:1. Excessive Boilerplate in the Call Chain The most common complaint is the boilerplate required when propagating exceptions up the call stack:void methodA() throws IOException { methodB();}void methodB() throws IOException { methodC();}void methodC() throws IOException { // Actual code that might throw IOException}<Every method in the chain must declare the same exception, creating repetitive code. While automatic propagation works well within a method, the explicit declaration in method signatures creates overhead.2. Poor Integration with Functional Programming Java 8 introduced lambdas and streams, but checked exceptions don't play well with them:// Won't compile because map doesn't expect functions that throw checked exceptionsList<String> fileContents = filePaths.stream() .map(path -> Files.readString(Path.of(path))) // Throws IOException .collect(Collectors.toList());<This forces developers to use awkward workarounds:List<String> fileContents = filePaths.stream() .map(path -> { try { return Files.readString(Path.of(path)); } catch (IOException e) { throw new UncheckedIOException(e); // Wrap in an unchecked exception } }) .collect(Collectors.toList());<3. Interface Evolution Problems Adding a checked exception to an existing method breaks all implementing classes and calling code. This makes evolving interfaces over time difficult, especially for widely-used libraries and frameworks.4. Catch-and-Ignore Anti-Pattern The strictness of checked exceptions can lead to the worst possible outcome—developers simply catching and ignoring exceptions to make the compiler happy:try { // Code that might throw} catch (Exception e) { // Do nothing or just log}<This is worse than having no exception checking at all because it provides a false sense of security.Improving Checked Exceptions Without Abandoning Them Rather than abandoning checked exceptions entirely, Java could enhance the existing system to address these legitimate concerns. Here are some potential improvements that preserve the type safety benefits while addressing the practical problems:1. Allow lambdas to declare checked exceptions One of the biggest pain points with checked exceptions today is their incompatibility with functional interfaces. Consider how much cleaner this would be:// Current approach - forced to handle or wrap exceptions inlineList<String> contents = filePaths.stream() .map(path -> { try { return Files.readString(Path.of(path)); } catch (IOException e) { throw new RuntimeException(e); } }) .collect(Collectors.toList());// Potential future approach - lambdas can declare exceptionsList<String> contents = filePaths.stream() .map((String path) throws IOException -> Files.readString(Path.of(path))) .collect(Collectors.toList());<This would require updating functional interfaces to support exception declarations:@FunctionalInterfacepublic interface Function<T, R, E extends Exception> { R apply(T t) throws E;}<2. Generic exception types in throws clauses Another powerful enhancement would be allowing generic type parameters in throws clauses:public <E extends Exception> void processWithException(Supplier<Void, E> supplier) throws E { supplier.get();}<This would enable much more flexible composition of methods that work with different exception types, bringing some of the flexibility of Rust's Result<T, E> to Java's existing exception system.3. Better support for exception handling in functional contexts Unlike Rust which requires the ? operator for error propagation, Java already automatically propagates checked exceptions when declared in the method signature. What Java needs instead is better support for checked exceptions in functional contexts:// Current approach for handling exceptions in streamsList<String> contents = filePaths.stream() .map(path -> { try { return Files.readString(Path.of(path)); } catch (IOException e) { throw new RuntimeException(e); // Lose type information } }) .collect(Collectors.toList());// Hypothetical improved APIList<String> contents = filePaths.stream() .mapThrowing(path -> Files.readString(Path.of(path))) // Preserves checked exception .onException(IOException.class, e -> logError(e)) .collect(Collectors.toList());<4. Integration with Optional<T> and Stream<T> APIs The standard library could be enhanced to better support operations that might throw checked exceptions:// Hypothetical APIOptional<String> content = Optional.ofThrowable(() -> Files.readString(Path.of("file.txt")));content.ifPresentOrElse( this::processContent, exception -> log.error("Failed to read file", exception));<Comparison with Other Languages' Approaches It's worth examining how other languages have addressed the error handling problem:Rust's Result<T, E> and ? operator Rust's approach using Result<T, E> and the ? operator shows how propagation can be made concise while keeping the type safety benefits. The ? operator automatically unwraps a successful result or returns the error to the caller, making propagation more elegant. However, Rust's approach requires explicit propagation at each step, which can be more verbose than Java's automatic propagation in certain scenarios.Kotlin's Approach Kotlin made all exceptions unchecked but provides functional constructs like runCatching that bring back some type safety in a more modern way:val result = runCatching { Files.readString(Path.of("file.txt"))}result.fold( onSuccess = { content -> processContent(content) }, onFailure = { exception -> log.error("Failed to read file", exception) })<This approach works well with Kotlin's functional programming paradigm but lacks compile-time enforcement.Scala's Try[T], Either[A, B], and Effect Systems Scala offers Try[T], Either[A, B], and various effect systems that encode errors in the type system while integrating well with functional programming:import scala.util.Tryval fileContent: Try[String] = Try { Source.fromFile("file.txt").mkString}fileContent match { case Success(content) => processContent(content) case Failure(exception) => log.error("Failed to read file", exception)}<This approach preserves type safety while fitting well with Scala's functional paradigm.Conclusion Java's checked exceptions were a pioneering attempt to bring type safety to error handling. While the implementation has shortcomings, the core concept aligns with modern type-safe approaches to error handling in languages like Rust and Haskell. Copying Rust's Result<T, E> might seem like the obvious solution, but it would represent a radical departure from Java's established paradigms. Instead, targeted enhancements to the existing checked exceptions system—like allowing lambdas to declare exceptions and supporting generic exception types—could preserve Java's unique approach while addressing its practical limitations. The beauty of such improvements is that they'd maintain backward compatibility while making checked exceptions work seamlessly with modern Java features like lambdas and streams. They would acknowledge that the core concept of checked exceptions was sound—the problem was in the implementation details and their interaction with newer language features. So rather than abandoning checked exceptions entirely, perhaps we should recognize them as a forward-thinking feature that was implemented before its time. As Java continues to evolve, we have an opportunity to refine this system rather than replace it. In the meantime, next time you're tempted to disparage checked exceptions, remember: they're not just an annoying Java quirk—they're an early attempt at the same type safety paradigm that newer languages now implement with much celebration. What do you think? Could these improvements make checked exceptions viable for modern Java development? Or is it too late to salvage this controversial feature? I'm interested in hearing your thoughts in the comments.
#java#exceptions#checkedexceptions
Public
Susan Larson ♀️🏳️‍🌈🏳️‍⚧️🌈

#Wisconsin #SupremeCourt #justice #opposes #request to #reinstate a 175-year-old #abortionban, calling it “the #world gone #mad.”

#Justice #JillKarofsky noted the 1849 #ban lacks #exceptions for #rape or #incest and may cause #doctors to withhold #care from #women due to #fear of #prosecution.

#Women #Transgender #LGBTQ #LGBTQIA #Wisconsin #WomansRights #AbortionRights #Conservatives #Extremism #Fascism #Religion #RepublicanParty #Misogyny #ThePartyOfHate #EmptyThePews

thepinknews.com/2024/11/14/wis

PinkNews | Latest lesbian, gay, bi and trans news | LGBTQ+ news · Wisconsin Supreme Court justice opposes request to reinstate state abortion ban: ‘The world gone mad’By PinkNews Reporter
Public
Rob Carlson :ally: :BLM:

Here with Mansi for “#Programming and #Parenting”, some notes:

- #Iterative development: adjustments and bug fixes as you go, for kids is Sleep, routines, feedback from reactions
- Handling the unexpected: How do you handle #exceptions cleanly? How do you react to random kid behavior?
- Debugging: #test solutions until problem is solved, for kids there will be a solution eventually
- Balancing #complexity: Only when absolutely necessary, one step at a time for processes
- Celebrate wins - When you solve, brag about it, when kids to the same congratulate them

An individual is presenting at a conference or workshop, standing in front of a projector screen displaying a "Thank You!" slide. The person, identified as Mansi, is smiling and gesturing, wearing a maroon jacket over a blue shirt.
#bcphilly#barcamp
Replied in thread
Public
Kent Pitman

@screwtape

Well, the totality can be a function of other than args, so something that takes any kind of args can still err for other reasons. I don't know if that helps.

I don't know if you've read these papers but you might find them a bit more abstract:

nhplace.com/kent/Papers/Except

nhplace.com/kent/Papers/Condit

The second of those is mostly more advanced topics, as I recall. But the first is a discussion of the same issues as you find in Revision-18.txt, but in a way that is hopefully more abstract. That 1990 paper won a Best Paper award at the First European Conference on the Practical Application of Lisp, so I assume it was decently readable. It was just a dusting off of the paper I'd written in 1985 that no one had really cared about for 5 years. Since the paper was already written, I used the prep time for the conference to polish, and to whittle away anything about the paper that might not look like a "best paper", which apparently worked. :)

The 1985 paper is here, though I recommend just reading the 1990 version. I just often speak in hypertext and feel compelled to link things I talk about:

dspace.mit.edu/bitstream/handl

#lisp #CommonLisp #exceptions #errors #ErrorSystem #ConditionSystem

cc @masso

www.nhplace.com``Exceptional Situations In Lisp'' by Kent Pitman (March, 1990)
Public *
Susan Larson ♀️🏳️‍🌈🏳️‍⚧️🌈

#Women in #Texas being denied #Healthcare for potentially #fatal #ectopic #pregnancies proves #exceptions are a "#farce", experts say.

Two #complaints filed against #Texas #hospitals reflect a bigger #issue about #abortion #ban #exceptions

#Women #Transgender #LGBTQ #LGBTQIA #Texas #Abortion #WomansRights #AbortionRights #Health #Healthcare #Conservatives #Extremism #Fascism #Religion #Hategroups #RepublicanParty #Misogyny #ThePartyOfHate #EmptyThePews

salon.com/2024/08/15/texas-wom

Salon.com · Texas women denied care for ectopic pregnancies proves exceptions are a "farce", experts sayTwo complaints filed against Texas hospitals reflect a bigger issue about abortion ban exceptions
Replied in thread
Public
cRingeFest

@trebach

Changing #tense could be more difficult but...

Took me about 2 years (at a few hours a week) to manually iron out all the #exceptions, but was able to change the #gender of a 25 chapter ancient #text:

yesu.neocities.org/

Now i wish i'd kept a better #list of all the words and the changes made so i could possibly mecanically reproDuce the text gender #transition somehow on other texts.

The original idea was to have a person choose the gender of the text on the fly, but changing it manually once ended up being too much for me! }

yesu.neocities.orgWho, me? YesU
Public
beSpacific

#Texas Supreme Court Rules Against #Women Denied #Abortion Care Despite Dangerous #Pregnancy Complications. In Zurawski v. State of Texas, court refuses to provide clarity on #exceptions to state abortion #bans. reproductiverights.org/zurawsk #civilliberties #femicide #medicalexceptions #privacy #surveillance #HIPAA does not ensure #privacy of #medicalrecords - data collection on womens #pregnancy are underway in the same states who are shredding womens bodily #autonomy. #legalresearch #courts #MAGA

Center for Reproductive Rights · Texas Supreme Court Rules Against Women Denied Abortion Care Despite Dangerous Pregnancy Complications | Center for Reproductive RightsIn Zurawski v. State of Texas, court refuses to provide clarity on exceptions to state abortion bans. In Zurawski v. State of Texas, court refuses to provide clarity on exceptions to state abortion bans.
ExploreLive feeds
About