Threads for lcapaldo

4

lcapaldo 9 months ago | link | on: Does anyone know of a way to throttle my own internet connection?

Assuming the windows tag is accurate, Clumsy can do just this (slow all network connections etc).

3

apy 3 years ago | link | on: RobustIRC - IRC without netsplits

IME a netsplit is when two irc servers have a partition between them. This does not seem to address that situation but rather just when the client has a connectivity issue. Am I missing something?
1. 3
  
  lcapaldo 3 years ago | link
  
  No netsplits on server unavailability
  
  Traditional IRC networks split whenever a server has brief network connectivity issues to the rest of the IRC network, or whenever a server needs to be upgraded. With RobustIRC, your users will not notice when you roll out a new version or reboot the machine on which a particular RobustIRC server is running.
  
  Maybe the page changed, but that seems directly aimed “two irc servers having a partition between them”?
  1. 2
    
    apy 3 years ago | link
    
    A brief hickup of your internet connection means your session will be terminated in traditional IRC. With RobustIRC, you will transparently be connected to a different server.
    
    This sounds to me like clients
    1. 8
      
      mbrubeck edited 3 years ago | link
      
      RobustIRC handles both server and client connection interruptions. On the server side, it uses the Raft consensus algorithm to maintain consistent state in the presence of server failures and network partitions.
      
      On the client side, it uses the RobustSession protocol instead of a long-lived TCP connection, so that each message a client sends can go over a new connection, to a different server if necessary. This handles the case where the client’s original server goes away, as well as the case where the client’s network connection is interrupted.

14

mykola 3 years ago | link | on: Less is more: language features

Daira Hopwood gave an amazing talk at the Emerging Languages Camp at Strange Loop 2013 where she introduced her language, Noether. The core conceit is that it decomposes into sub-languages, hierarchically, which each sub-language adds a single new capability (thereby potentially introducing a new class of bug). The idea would be that you write your feature in whatever sublanguage gives you only those features you need, without pulling in higher-level capabilities (and their attendant bugs) unless you specifically need them. If you do, you block off that unit of code in its own sort of sandbox.

Really neat stuff. https://thestrangeloop.com/sessions/noether-symmetry-in-programming-language-design
1. 6
  
  lcapaldo 3 years ago | link
  
  A recording of the presentation: http://www.infoq.com/presentations/noether
2. 5
  
  craigstuntz 3 years ago | link
  
  This was indeed a really interesting talk. Many parts were relevant to this discussion. One I particularly like is the notion of separating the ability to throw exceptions from the ability to catch them. Throwing “out of memory” makes sense (even if it is a goto in disguise!); catching it does not, for the most part.

2

lcapaldo 4 years ago | link | on: What are some of your favorite learning projects or toy implementations and why?

I like http://www.windley.com/archives/2007/03/applied_web_heresies_etech_2007.shtml as a toy/learning project.

2
ika 4 years ago | link | on: What is type safety?
This isn’t a very good article for other people to learn from - but I’m sure the author learned from writing it, which is great!

He says that type safety isn’t something you can can easily pin down but it is easy to pin down. There are two types: A language that is statically or strongly typed and a language which is dynamically typed.

As for static typing: There are two static properties which define what it means for a language to have type safety: Preservation and Progress.
- Preservation is the claim that the type of a program doesn’t change during evaluation.
- Progress is the claim that a well typed program will be able to evaluate completely, rather than get stuck or perform some kind of undefined behavior.
Languages with dynamic typing don’t have either of these properties but they do perform runtime checks to avoid coercing objects of one type as if they were another.
1. 1
  lcapaldo 4 years ago | link
  I’m not sure I fully understand what progress means. Is something like:
  
  int f() { while( 1 ) {} }
  
  type safe?
  1. 2
    
    ika 4 years ago | link
    
    I understand your question but let me be careful about terminology first: Type safety is a property of a language not a piece of code, given a type system a piece of code could be determined to be well typed or not.
    
    Progress says that you will always be able to continue evaluation/execution, it doesn’t require that it should terminate so a language with infinite loops can still have progress. An example of blocking progress would be if a broken type system somehow thought 3 + “foo” was well typed, then it had no rule to execute plus on different types of value.
    1. 2
      
      lcapaldo 4 years ago | link
      
      Thanks, that definitely clarifies it.

2
rseymour 4 years ago | link | on: Why were there gotos in apple software in the first place ?
gotos are fine, but this serves as an “I told you so moment” for people who like:
```
if (x) {
    goto fail;
}
```
over
```
if (x)
    goto fail;
```
1. 1
  
  kragen 4 years ago | link
  
  Or people who like Python indentation-based syntax.
  1. 1
    zhemao 4 years ago | link
    
    How would that be an issue? If Python hypothetically had gotos, then
    
    if something: goto fail goto fail
    
    Would still work properly because the indentation level would be right.
    1. 2
      
      kragen 4 years ago | link
      
      I mean that this serves as an “I told you so” moment for people who like Python indentation-based syntax, precisely because it would work properly — you can’t have the kind of misleading indentation in Python that was the problem here.
    2. 1
      
      lcapaldo 4 years ago | link
      
      I believe that is the point, it’s not an issue if things work like Python instead of C, that it serves as an “I told you so” for those who would equate indentation with block structure.
2. 1
  ap edited 4 years ago | link
  Personally I like
  
  if (x) goto fail;
  
  and
  
  if (x) { goto fail; }
  
  :-)
  
  (Not only does this style make it impossible for the programmer to forget to fix the presence/absence of braces when switching from one variant to the other. I just realised it also makes it impossible for the computer to mis-merge such code, if indeed that hypothesis is correct about how this duplicate goto fail happened. I.e. with this style such code must either merge correctly or cause a merge conflict.)