daotoad

New features have been coming out with yearly releases since 2010's release of version 5.12.

But by 2010, many people already thought Perl5 was dead because Perl6 still hadn't shipped.

The really interesting stuff is actually happening on CPAN, with great extensions like:

* Type::Tiny https://metacpan.org/pod/Type::Tiny

* Kavorka https://metacpan.org/pod/Kavorka

* Moo https://metacpan.org/pod/Moo

* the Test2 suite of unit testing tools https://metacpan.org/pod/Test2::Suite

(edited for clarity, hn formatting is a pain)

There's also a nice interface for writing command line utilities that takes advantage of the above.

See my Christmas themed 2018 Perl6 Advent Calendar article on the topic: https://perl6advent.wordpress.com/2018/12/16/day-17-checking...

2. Whether you go positional or use an options hash, you still need to carefully unpack your args at the top of the subroutine. And do it consistently. There are a ton of libraries to help with this, too.

The most important thing is to pick a house style and do it everywhere that doesn't need to be different.

This is pretty onerous, but it should be pretty damn good at rejecting bad candidates.

I do wonder how many good or great candidates you lose with this method, though.

Imagine how much better the Star Wars prequels could have been if only Lucasfilm had a strong No Person to stop them from doing stupid shit.

If you've ever written or worked on a classical desktop application, you'll know what I mean. Since (at least) the 90s there have been visual UI builders and geometry management tools that allowed you to easily define a responsive user interface and connect widget events with calls to back end code. With the advent of CSS Grid and Flexbox, we finally have two decent geometry management tools--it only took 20 years. Except I can't use them yet, I have to support terrible old browsers (like IE7) that are embedded in customer applications.

We've been involved in reinventing a pretty, zero-config version of X-Windows, and we're only about 60% of the way done. How much further would we be if we didn't insist on building it in a hopped up word-processor?

I believe "plan b" is a head first compound noun, and should pluralize like "hangers on", "mothers in law", or "attorneys general".

But I could be wrong. The plural form doesn't get much usage.

The managers work as an interface between the management hierarchy and the individual contributors.

The top engineers work across teams to steer technical solutions and provide cross team focus and continuity. Your principal engineers are charged with breaking down the silos and sharing and setting technical standards and encouraging the reuse of existing services and systems.

Tech managers and team leads don't have time to do the technical leadership and work properly with business. Workplaces without this structure invariably fail to have well articulated, cross team technical decision making capabilities. Everything winds up fragmented and reimplemented.

Recent Perl versions have function signatures.

Have you tried the Test2 test suite? It’s a tremendous improvement over the previous system.

Type::Tiny is an amazing library that provides a rather nice type system.

https://www.bloomberg.com/news/features/2019-03-15/what-s-a-...

I, for one, am irritated by the name and hope they either change it or that the project fades. Things are confusing enough without this kind of nonsense. Yes, I get that each cell in a spreadsheet is observing its neigbors. Yes, it's nice that you can "observe" your code auto updating. Yes it's nice that people are trying to improve upon spreadsheets as a programming model. Don't be purposely obtuse right out of the gate by naming your project after a widely used pattern, tool or technique. Call it Cells or Panopticon or something. Please.

In other news, check out my new web framework, called MVC.

The nice thing is that the automation tools are being made progressively easier to customize. That means that it is easier to define your own standard and support it with standard tooling.

Example: I am weary from investing so much time and effort in Apple's platform. Being so deeply invested, I am wary of further investments until I can diversify.

This is confusing as hell because "wear" sounds the same as "ware" and weary is a real word and will not upset your spellchecker. Of course "weary" sounds different than "wear", with the first sylable rhyming with ear. Thanks English.

Anyhow, misuse of words like this reduces the impact of your communication. I hope this explanation can help you be a bit more effective in expressing yourself.

IE6 was a browser of the same era as Netscape 4, when it was common and unsurprising for a CSS error or a malformed bit of HTML to crash the browser.

The biggest companies will just form overseas business units and employ now "local" people in order to avoid these restrictions. Addressing this sort abuse while keeping the flow of capital reasonably free is a bit more of a challenge.

Here's an article that attempts to answer your question, and goes into great detail:

https://www.oregonlive.com/foodday/2012/07/which_sweet_onion...

TLDR: Vidalia is milder. Walla Walla has a more complex flavor profile.

I live in a all party consent state, so if you want to record a conversation with me, legally, you need to have my consent.

Some states are one party consent states. You can record any conversation you want.

Across state lines, federal law requires only consent of one of the parties. But that doesn't resolve anything. Courts in different states handle cross-border complaints differently, some enforce their local all party standard, others demure to the other jurisdiction's one party laws.

In Perl6 I can document those requirements in the subroutine signature:

  sub foo( Str $name where *.lines == 1, Int $count where * > 0 ) {
      say "Name is $name with count $count";
  }

  subset LegalName of Str where *.lines == 1;
  subset PositiveInteger of Int where * > 0;

  sub bar( LegalName $name, PositiveInteger $count ) { foo( $name, $count) }

  # Print a single line argument.
  multi sub print-it( Str:D $it where *.lines == 1 ) {
    say $it;
  }

  # Print a multiline string as a single line
  multi sub print-it( Str:D $it ) {
    say $it.lines.join('');
  }

  # Handle anything that we didn't expect
  multi sub print-it( Any $it ) {
    Failure.new( "it was unprintable", $it.gist );
  }

A powerful IDE that automatically looks up documentation and guides you through writing a bunch of boilerplate lets a language designer skimp on figuring out ways to let you avoid writing the boilerplate in the first place.

Code generation in the IDE is a poor substitute for a well designed interface.

https://www.owasp.org/index.php/Top_10-2017_A1-Injection

Is there any escape?

The flashbacks you were experiencing were very real traumatic flashbacks, like what a victim of violence would experience.

The promising results that psychologists are having with psychedelic drugs all centers around having a trained operator guiding the experience to get a desired effect. It's not just a matter of dropping acid and you immediately see GOD and fix your PTSD.

Jonathan Worthington can write and speak about this topic far better than I can so I refer you to his talk and slides:

1. http://www.jnthn.net/papers/2018-conc-par-8-ways.pdf 2.C https://www.youtube.com/watch?v=l2fSbOPeSQs

Fortunately the error messages are very good.

As to mixing variable names up with subtraction, you put spaces in your math formulas? someVar-anotherVar*thirdVar is pretty unpleasant to read, so not being able to do that is not much of a problem.

Perl6's relationship to sigils (like $) is a bit weird at first, but is very consistent and "fits lightly under your hands" in practice. Suffice to say, sigils indicate context and constrain the type of data you can put in a container. If you want to refer directly to a value, you use a sigil-less variable:

  my \the-great-answer = 42;

This code should be readable enough to give you an idea what is happening and how to change it.

  my $board-depth = 8;
  my $board-width = 8;
  
  my $squares = $board-depth * $board-width;
  my @grains-per-square = ( 1 .. $squares ).map({ 2 ** ($_-1) })
  
  say [+] @grains-per-square;

Hint: `[]` is the reduction metaoperator, it lets you specify an operator to use when reducing a list. [+] means "add it up".

It finishes basically instantly, and while Perl6 has gotten a lot faster, it is not a fast language (yet?). So no need to optimize this.

I mean you write the code and then marketing will have a poorly specified variation like "double only the odd ones".

If you implemented this as `2^64-1` then you are starting from scratch.

For the above the map only needs a tweak:

  map({ $_ %% 2 ?? $_ :: 2**(n-1) })

In the article, I didn't see informational intentionality, I saw premature optimization and obfuscation.

The Story of Bunny Showers:

I worked on a code base where we had, in one class, seemingly endless variations on the spelling of "business hours". There were variables named `bsns_hrs`, `business_hours`, ` business_hrs`. Furthermore, in the object's (horrible, messy, overlarge, mutable as fsck) internal state, there were elements labeled with `busnessHours`, `bsnsHours`, 'business-hours`, 'bnshrs`. And so on.

My habbit when reading code like this is to map each spelling to a phonetically similar word or phrase. So `business_hrs` becomes "business hers" and `bnshrs` becomes "bunny showers". And so forth. It makes it easier to rationalize about what is happening, especially if, like me, you move your lips when you read.

I have ever since called this issue of inconsistent spelling in code the "bunny showers" problem, owing both to the well-known fecundity of rabbits and the hellish proliferation of inconsistent names in that fabled codebase.