Best way to get a software job in Europe? - <AUTHOR>

I'm a newbie when it comes to working outside the U.S. so I don't know which job sites are the best to search, but I'd love to get a software development job in Europe(specifically for Java technologies). Granted, I don't speak multiple languages fluently so I may be at a disadvantage. What is the best way to find and apply for software jobs in Europe? <comment><USER2> I work for Accenture. I know they have a good presence in Europe, and lots of Java jobs.</comment>


Ask HN: Any places for early products, alpha stage, to get users and feedback? - <AUTHOR> I have at least two side projects and would love to get feedback from fellow UX/Product/Engineering people.
This is super early stage stuff, I wouldn't even call it beta. I am not comfortable having non-professionals look at this :)
Even someone to just try the app or look at my flows would be good at this stage. Does anyone know any good places for something like this? <comment><USER2> You need to get feedback from potential _users_. Where do your users hang out?</comment>


Graphical Introduction to Dynamic Programming - <AUTHOR> https://avikdas.com/2019/04/15/a-graphical-introduction-to-dynamic-programming.html <comment><USER2> The best resource I've used for learning dynamic programming and actually having it click is the DP lectures from the OMSCS Graduate Algorithms course.

[https://www.udacity.com/course/introduction-to-graduate- algo...](https://www.udacity.com/course/introduction-to-graduate-algorithms-- ud401)

<comment><USER3> Hi, author of the article here.

I'm definitely a fan of structured education. After all, what I learned about DP I learned from a fantastic college course. Glad to hear there are online resources for people to get that kind of education, so thanks for sharing!

Hopefully, an article like mine can help those who are not able invest in more lengthy study, or just need an additional perspective.

<comment><USER4> This article is fantastic, thanks so much. I kid you not, I was already planning to learn about DP tonight and then I saw this article and I'm done! I get it.

The tricky part to learn, and one that I'm sure comes with experience, is how to identify the subproblem + recurrence relation. One thing this clarified for me is the construction of the grid and how it is dependent on inputs because of the DAG. But you can have a recurrence relation that uses more than two sub-problems. i.e. the DP method for calculating Levenshtein distance involves a recurrence relation with 3 previous values (subtraction, addition, substitution).

<comment><USER3> Glad I was able to reach you at the right time :)

You're absolutely right about figuring out the subproblems and the recurrence relation. I've found that knowing how you're going to use the recurrence relation is a first step to coming up with the right relation. For example, knowing you'll cache the results in a table means you're on the lookout for a function that has integer inputs, because you want the values to be indexed and ordered.

After that, as you said, practice is key. I'm working on a follow-up article that'll show some tougher examples, which should help provide more exposure. Forget three sub problems; one problem, the chain matrix multiplication problem, uses O(n) subproblems!

</comment></comment></comment></comment><comment><USER5> A little over a year ago I went looking for somewhat involved real world applications to motivate a discussion of dynamic programming, and I quickly stumbled into options valuation, specifically the Binomial Option Pricing Model (BOPM).

[https://reindeereffect.github.io/2018/03/08/options- valuatio...](https://reindeereffect.github.io/2018/03/08/options-valuation/)

<comment><USER6> I originally came across dynamic programming when attempting to implement the "seam carving" algorithm used in content aware image resizing (and, to my understanding, used in a handful of smart image editing features in Photoshop these days)

[https://en.wikipedia.org/wiki/Seam_carving#Dynamic_programmi...](https://en.wikipedia.org/wiki/Seam_carving#Dynamic_programming)

</comment></comment><comment><USER7> This was really helpful! I've seen the coin change problem before, but not been able to solve it.

</comment><comment><USER8> I think the biggest problem with dynamic programming is its name. I'm not sure what I would call it, but "iterative memoization" comes close for the bottom- up approach.

<comment><USER5> From the Wikipedia page for dynamic programming:

 _The word dynamic was chosen by Bellman to capture the time-varying aspect of the problems, and because it sounded impressive.[11] The word programming referred to the use of the method to find an optimal program, in the sense of a military schedule for training or logistics. This usage is the same as that in the phrases linear programming and mathematical programming, a synonym for mathematical optimization._

[https://en.wikipedia.org/wiki/Dynamic_programming#History](https://en.wikipedia.org/wiki/Dynamic_programming#History)</comment></comment>


Boris Mann, Bootup Labs Co-founder leaves the startup accelerator - <AUTHOR> http://blog.bootuplabs.com/2010/05/03/boris-getting-off-the-roller-coaster/

<comment><AUTHOR> His personal blog post here <http://bmannconsulting.com/2845/personal/roller- coaster></comment>


Writing Safe Shell Scripts (2019) - <AUTHOR> https://sipb.mit.edu/doc/safe-shell/ <comment><USER2> Make sure to have ShellCheck either integrated in your editor or run it before executing.

It really tells many of the rules you're supposed to abide by and helps you write cleaner shell script.

[https://github.com/koalaman/shellcheck](https://github.com/koalaman/shellcheck)

<comment><USER3> Quick reminder that ShellCheck is licensed under the strict GNU GPL 3.0 license. For many professionals your employer will often block / avoid GPL code, tools, and libraries.

<comment><USER4> Sorry, but what employers block the use of GPL tools? Most employers that write proprietary software don't want GPL code in their code, but using a tool like shellcheck to perform static analysis on your code doesn't make that software that was analyzed now subject to the GPL, so why would they block it?

<comment><USER5> Apple is strongly anti-GPL. And they're pretty open about that.

Most companies that are anti-GPL aren't so open about it.

<comment><USER4> I get that Apple doesn't want GPL code included in their software, but their engineers can still use GPL tools without fear of opening up their proprietary code. I know of plenty of companies where you can not _INCLUDE_ GPL code in the software the company makes, but I don't know of any company that says you can not _USE_ any GPL software to do your job. Those are two different things.

<comment><USER5> For the six month contract I did at Apple, they were violently opposed to using any GPL software in any way, shape, or form.

Just because you can do something, doesn't necessarily mean you should. That rule applies to the implementation of corporate policies regarding licensing, too.

</comment></comment></comment></comment></comment></comment><comment><USER6> This is the kind of ignorance (just use python for anything it's better + and discover subprocess(): it's great) that burns me up. Not so many years ago actively insisting that python/tcl/perl were to be used instead of a 50 line shell script would have gotten you kicked out of a serious discussion. You used the power and reflection of these languages when you needed something that didn't integrate cleanly with the rest of the unix toolkit and/or required sophisticated data structures, controls and abstraction. These days I won't even write python or tcl for trivial projects (including http API work just use curl/jq and bash/(g)awk). The number of shell one liners that just get things done in 30 seconds (rather than loading 5 libraries in python to write the same code) are innumerable. This is google thought policing the historically ignorant yet again. They are terribly opposed to the unix toolkit and C pragma that prevailed for 20 years...because they believe that they know the best way to make the world safe and productive. Self serving, smug rejections that serve the bottom line and coincidentally gain mind share for their products and approaches.

<comment><USER7> Hear hear! It tears at my heart that the next generation of admins think Python is the answer to everything. It's a systemic rot of the core of *nix understanding.

I'll probably get flamed for this, but Python is an absolute fucking trainwreck of a platform. Even at its core the 2.x vs 3.x is going to break all kinds of stuff in Jan 1, 2020. Just look at the package system: cross- system portability is a mess (don't believe me? run on Arm for a week), and unfortunately because there IS a package system people think they HAVE to use it, which means: BLOAT BLOAT BLOAT your BOAT, gently down the stream!

It's kinda like what Dewalt did to miter saws. We've gone from something that could be kept perfectly square and did a great job and took up a little bit of space, to 30+kg behemoths with sliding rails and double bevels, tons of blade travel and deflection, and are a challenge to keep true and take up 3x the space and weigh a ton.

Keep your mission-critical tools simple. Period.

</comment></comment><comment><USER8> I really wonder whether there is really any point in writing shell scripts anymore. Practically every Unix/Linux box in existence has at least some version of Python 2 that can be used as a complete and total replacement. I can't think of a single situation where I would need a shell script and a Python script wouldn't be much cleaner, simpler, and more maintainable.

<comment><USER9> I've yet to find a programming language that makes I/O redirection, piping, and process substitution[1] as easy as Bash does. Process substitution is where the shell really shines, in my opinion.

Bash, and Bash-like shells, are literally everywhere. I have to be wary about what Python 3 features I use, and if there will even be a Python interpreter available. My OpenWRT router has a Bash shell, but I don't care to install and maintain other interpreters or runtimes on an embedded platform.

Even job management and parallelism are easier in Bash and GNU Parallel.

[1] [https://www.tldp.org/LDP/abs/html/process- sub.html](https://www.tldp.org/LDP/abs/html/process-sub.html)

<comment><USER10> PowerShell, mostly because PowerShell was designed as a mashup of Bash and C#.... And it's kind of a trainwreck in a lot of ways.

It really feels like piping and easy process invocation and compile-time directory awareness wouldn't be massively onerous to add to an existing full- featured programming language so you wouldn't have to sacrifice a good type system and powerful syntax when you want to do scripty things.

<comment><USER11> As I understand it, PowerShell came about because porting the standard Linux/Unix utilities to Windows didn't work out.

PowerShell meets both requirements as it's tuned for the Windows environment, but can still play nicely with the rest of the world.

Of course, now that WSL is a thing, it's a real question why someone would want to use PS unless they had no other options.

[https://www.heavybit.com/library/podcasts/to-be- continuous/e...](https://www.heavybit.com/library/podcasts/to-be- continuous/ep-37-the-man-behind-windows-powershell/)

<comment><USER12> PowerShell has real data structures (arrays and hash tables), built-in functional programming tools (Select-Object, ForEach-Object, Where-Object), GUI cmdlets (Out-GridView) and direct access to .NET libraries. It's a viable tool for many complex tasks where on Unix, you'd need to reach for Python rather than a shell.

</comment></comment></comment></comment></comment><comment><USER13> Shell scripts have their well-deserved place in Unix systems. A general recommendation to use Python or other high-level scripting languages without a discussion about the reasons why and when to use shell may lead to wrong conclusions.

<comment><USER14> I'd love to read a good blog post on when to use shell scripts vs Python or other programming languages, which seem far more accessible to me.

<comment><USER15> If all you need to do is chain together external programs, set environment variables, redirect filehandles, iterate over files, etc with the tiniest bit of logic, and don't want to have to set up an execution environment or download something to do it, and want ultimate Unixy portability, and you want virtually anyone to be able to read and maybe modify it, you want shell.

If you need to do a very specific task that involves interpreting/modifying data structures/formats, if you have non-trivial logic, if you need to use a module, if you need to access an operating system primitive which Unix shells don't really expose, if there's no Unix tool that does what you want, or you just need more control/certainty/reliability, you want Python or something else.

<comment><USER14> The funny thing though is that the "virtually anyone" part seems to me more likely to happen with python - or with any mainstream programming language - than with what seem to me like deeply arcane shell incantations.

</comment></comment></comment></comment><comment><USER16> I'm not sure I'm comfortable with python for a typical shell script. But then again, what alternatives exist?

I've been thinking that we are kind of stuck with it. Much like javascript.

So, we could go the route of typescript and have a translation layer and outputting shell scripts. I actually think that could work quite well from a technical standpoint.

A big part of shellscripts though is having the source available. So maybe even have the translated, original code, and the generated shell output in the same file.

The source code on top (out of view from a shell interpreter) and the generated code below. This would allow it to be readable by anyone and executable by anyone, but modifying it would require the transpiler (which by itself would probably be pretty lightweight as well - certainly compared to python).

Certainly not perfect, but preferable to rediscovering the nuances and gotchas of shell-scripts every other day. Or maybe such a solution would only prolong the suffering and we should start all over.

<comment><USER17> What's wrong with python?

<comment><USER16> Feels like the wrong tool for the job with the whole virtual environment that has to be brought up.

Performance for shell scripts isn't super critical in my eyes but the startup time of python feels too much for something you might want to run in an inner- loop from find or something. Not sure if python IO performance is suitable for shell scripts either.

Also isn't nearly as universal as shell-scripts nor something you necessarily have/want on small systems.

But I will admit that I'm channeling prejudices and don't feel I have enough of a complete picture to say anything definite about it. Others in this thread touch upon it though.

<comment><USER17> You don't _need_ a virtual env.

I probably wouldn't wrap GNU find and python, I'd just walk the directory tree in python and use regex.

IO is suitable for everyday tasks and shouldn't be an issue in Python anyway, if it is either you're doing it wrong or your shell script should be written in C and not touch interpreted/bytecode compiled languages at all.

<comment><USER16> Me neither, but a big point of shell scripts is that they are the same commands you'd run on the shell itself.

And there are lots of really optimized tools that are as quick as can be, throwing them out is a hefty price to pay.

</comment></comment></comment></comment></comment><comment><USER18> Some time ago I started to doubt if using 'set -e' is a good idea.

I mean, if it would work as you expect it to, it certainly is a good idea to exit a script as soon as something fails. But sadly not all implementations behave similarly [1] and if you call a function from within a condition, 'set -e' gets deactivated/doesn't work.

For illustration, take a look at the following example:

      #!/bin/bash

      foo() {
        set -e
        false
        echo "Sucks"
      }

      printf 'Normal: %s\n' "$(foo)"
      printf 'Condition: %s\n'  "$(foo || true)"

Output:

      Normal:
      Condition: Sucks

Probably not what you would have expected. Not using 'set -e' is no good solution either, so, for the time being, I still use it, but I am still looking for a better solution.

[1] [https://www.in-ulm.de/~mascheck/various/set-e/](https://www.in- ulm.de/~mascheck/various/set-e/)

<comment><USER19> If I have something I know can fail, and I want it to be able to, then calling set +e before it, and recalling set -e afterwards is the way I handle it.

But, in this case, because you're running it in a subcommand, you need to add pipefail.

        set -euo pipefail

This way of making sure nothing misbehaves also locks out unset vars, which can be surprising, but also helpful.

<comment><USER18> As far as I can tell, adding pipefail or nounset doesn't change the behavior in this case.

In my opinion, the problem is that calling a function from a test expression, evaluates it in a different manner than calling it from elsewhere. That is so absurd that I wonder how it wasn't changed over the years.

</comment></comment></comment><comment><USER20> Can mktemp fail? I recently wrote a script that ensures that the directory created by mktemp actually exists and starts with /tmp so that when the script wipes out its temporary data at the end, it will not ever run something like "rm -rf /". Using fully-qualified paths for everything is also (not) fun.

In another script I was leery about running rm -f -- /path/foo* so I instead used

      find /path -mindepth 1 -maxdepth 1 -name "foo*" -delete

because then the glob can't affect find's behaviour in weird ways.

Most likely set -e is enough protection against mktemp failing and the rm -f glob _probably_ would've been just fine, but shell scripting has enough footguns that sometimes I can't help but go overboard with paranoia.

<comment><USER21> Yes, mktemp can fail.

For example, "TMPDIR=/dev/null mktemp -d" will reliably fail.

You shouldn't be validating it starts with "/tmp" though, because on quite a few systems, people set TMPDIR=/var/tmp.

You absolutely should check if mktemp exited nonzero, but if it exited 0, the directory should be safe to use. If you want to be really paranoid, you can check if the output is an empty string too after checking the exit code.

I think you're shying a little too far away from bash's globbing. Yeah, bash has footguns, but using clever workarounds can also be a recipe for creating confusing and error prone code in its own way.

<comment><USER22> Please tell me it's enough to check the exit code! That's all I ever do and I have hundreds of mktemp scripts out there.

In the end I think shelling is mostly about controlling your inputs.

<comment><USER23> Not just inputs, unfortunately. TOCTOUs (and races in general), for instance, are very common problem in shell scripts.

<comment><USER24> Races and TOCTOUs are generally common problems in most concurrent systems that are not considering atomicity by design (e.g. rdbms). It's just that shell can very easily become concurrent...

</comment></comment></comment></comment></comment><comment><USER25> I'm constantly surprised that we got a safe language that compiles to Javascript (TypeScript) but never got a safe language that compiles to shell script. Why can't I write in (a subset of) some other scripting language $lang, but with restricted-to-pure-/bin/sh semantics, and then cross-compile it to actual portable shell script for distribution?

Hopefully not by generating a megabyte of polyfill runtime code; more just by the compiler refusing to compile code in $lang unless it has a direct equivalent in /bin/sh. Any $lang source file the compiler accepted, would just look like "a shell script translated into $lang" already. But the compiler would inject $lang's safe semantics (exceptions, type-checking, etc.) during the compilation, so you'd at least get that benefit.

Alternately, I'd _also_ be satisfied with "emscripten for shell": a compiler that generated shell scripts containing a small WASM-like emulator and an embedded bytecode stream to feed it. As long as it was lightweight enough. (A large point of these environments' use of /bin/sh is that they're small and embedded and can't load too much into memory at once.)

My only guess for why this hasn't happened, is that the people who write things like shell scripts that execute in initramfs, or shell scripts that are intended to install stuff even on lesser-known UNIXes, are all old-hand ops people who know shell-scripting cold, and certainly _aren't_ developers with any experience in compiler theory.

<comment><USER26> Because doing so would be hard for shell scripts to express. real functions, try/catch, and other common language features are not often part of shell languages. As such, the generated code may not support many features you typed in <other lang> and/or the generated code would bundle a runtime with it to emulate what we'd otherwise consider pragmatic scripting feature support.

<comment><USER25> I mean, like I said, I don't want to use $lang features that don't exist in shell script. E.g., I want "exceptions" in the sense that adding a string- typed variable to an integer-typed variable will blow up in a descriptive way (or better, not compile); but I don't want real exceptions in the sense of being able to catch them. I just want everything to translate to the shell script aborting in verbose and helpful ways before doing something stupid with invalid inputs; or not compiling at all if there's a code-path that can't possibly be valid.

Also, I wouldn't mind if this $lang that compiles to shell script is its very own language I'd have to learn, just like TypeScript is its very own language you have to learn. As long as I don't have to manually write five layers of guards using impenetrable [ "y${x:-1}" -eq "f" ] style code, and then duplicate the hierarchy of cleanup behaviours after each failed guard, I'd be happy.

</comment></comment></comment><comment><USER27> Checking $PATH or explicitly calling outside resources is probably also advisible.

In general, this article seems very light. No mention of LD_LIBRARY_PATH, for example. I imagine there's probably a better guide to writing secure scripts somewhere else.

<comment><USER8> These sorts of security measures are only really necessary when you have a setuid or setgid shell script. (However, a much better suggestion would be to simply not write setuid or setgid shell scripts because they are a security nightmare.)

</comment></comment><comment><USER28> For more concrete recommendations in a similar spirit, check out [https://github.com/pesterhazy/blissful- bash](https://github.com/pesterhazy/blissful-bash)

</comment><comment><USER29> Instead of

        set -euf -o pipefail

please consider

        set -o errexit
        set -o nounset
        set -o noglob
        set -o pipefail

which is easier to lookup/search for if the reader is less familiar with shell scripting, and makes for cleaner diffs when a flag is removed/added.

Caveat: some of the longer forms might be Bashisms (e.g. not present in ksh, dash, etc.)

<comment><USER21> "which is easier to lookup/search for"

From my experiment:

Googling "set euf" (without quotes) -- 838,000 results, first 6 results are all helpful and explain it in detail.

Googling "set o nounset" (without quotes) -- 38,700 results, entire first page seems helpful.

I dunno, looks like they're identically easy to learn the meaning of.

<comment><USER29> "easier to understand/remember the meaning of" would have been better phrasing. I can remember/infer what `set -o noglob` does, but not `set -f`.

</comment></comment></comment><comment><USER30> Hi. Author of Next Generation Shell here.

Here is my take on bash vs Python and friends. I am frustrated by both.

bash - domain specific language and huge library (CLI utilities) and lets you get the job done but not a language I would like to use (syntax, error handling, very limited structured data support).

Python - okayish as a language but doing domain specific things (working with files and processes) is so much more verbose than bash.

My solution in NGS - have a _high level, modern_ language with the typical goodies like ... exceptions (wow, completely new concept!) and the language is still domain specific. Working with processes for example has it's own syntax and is much more concise and straightforward (stole bits from bash).

Right now the project has the language, which is useful enough to write scripts (which we do at work). Regarding contribution to the project, my idea is that as much as possible should be in NGS language (as opposed to the lower level C). The UI will be implemented completely in NGS, allowing contributing to the project using the _same language_ you are writing your scripts in.

[https://github.com/ngs-lang/ngs](https://github.com/ngs-lang/ngs)

As a side note, while the UI is not there yet, I do plans for it which include interaction with objects on the screen as opposed to current "here is your dump of text" situation... and in general be more considerate of the user.

[https://github.com/ngs-lang/ngs/wiki/UI-Design](https://github.com/ngs- lang/ngs/wiki/UI-Design)

</comment><comment><USER31> I find exceptionally difficult to write anything but trivial shell scripts without bugs. This one took years, and I suspect #bash could still find a bug: [https://github.com/jakeogh/commandlock](https://github.com/jakeogh/commandlock)

On the other hand, this is amazing: [https://github.com/speed47/spectre- meltdown-checker](https://github.com/speed47/spectre-meltdown-checker)

</comment><comment><USER32> Go write a shell script just like any other piece of code. Have fun!

</comment><comment><USER33> Here's my boilerplate bash header with comments describing each option, which I find practically helpful for starting new scripts

[https://gist.github.com/crizCraig/f42bc250754bed764ada5f95d1...](https://gist.github.com/crizCraig/f42bc250754bed764ada5f95d101dbea/)

raw: [https://gist.githubusercontent.com/crizCraig/f42bc250754bed7...](https://gist.githubusercontent.com/crizCraig/f42bc250754bed764ada5f95d101dbea/raw/e3814fdb85c42afcf5766abf039f51eed67d8068/bash_boilerplate.sh)

</comment><comment><USER34> I've done a bit of porting bash scripts to posix recently and I've found the following boilerplate pretty useful:

        case "$(readlink /proc/$$/exe)" in */bash) set -euo pipefail ;; *) set -eu ;; esac

That takes care of setting -eu for shells that don't support -o pipefail and pipefail for bash.

</comment><comment><USER35> I personally think "don't" is right. For those who are interested in trying to use Python instead, I found this to be a helpful resource: [https://github.com/ninjaaron/replacing-bash-scripting- with-p...](https://github.com/ninjaaron/replacing-bash-scripting-with-python)

<comment><USER36> I disagree, Python scripting will tie you to Python development uncertainties, while shell works with most operational environments.

<comment><USER37> That's a good point. Shell would not announce an EOL date for a specific version. Scripts that used to work 25 years ago, still work just the same. Python scripts that used to work 10 years ago, now need maintenance/porting, no matter how trivial, to make them work with Python 3.

</comment></comment></comment><comment><USER38> More useful tips in the same spirit

[http://robertmuth.blogspot.com/2012/08/better-bash- scripting...](http://robertmuth.blogspot.com/2012/08/better-bash-scripting- in-15-minutes.html)

</comment><comment><USER39> related: [http://redsymbol.net/articles/unofficial-bash-strict- mode](http://redsymbol.net/articles/unofficial-bash-strict-mode)

</comment><comment><USER40> Since it's bash-specific, I think people should use zsh instead. No need to quote variables as by default, splitting is not done. And you get access to arrays and associative arrays.

<comment><USER41> Bash has arrays.

        x=(1 2)
        echo "${x[0]}"

And associative arrays

        declare -A x
        x[hi]=20
        x[bye]=30
        echo "${x[hi]}"
        for i in "${!x[@]}"; do
            echo "k: $i, v: ${x[$i]}"
        done

</comment></comment><comment><USER42> On set -e:

This is like adding a setting to your Java or Python program to immediately exit if any method call throws any kind of exception, with no possibility of catching and handling that exception.

This does not seem to be a smart thing to do as compared to checking return codes, etc.

Every script I've seen with set -e has been buggier than without it.

The main problem with scripts is that they often do not go through a normal software review and testing process.

</comment><comment><USER43> The first piece of advice, "Don't", is the best. "shellcheck myscript.sh" should return a fatal error if the shell script file you're checking exists, and "shellcheck -f myscript.sh" should fix your shell script by removing it.

</comment><comment><USER26> Amen.

deno, node, python, julia--anything but shell scripting.

</comment><comment><USER44> At the beginning of each file:

        #!/bin/bash
        set -euf -o pipefail
        cd $(dirname $0)

Then add "" everywhere ;) And they say, write Python instead, except I'm dubious because python programs can have a lot of dependencies which can be tricky to install.

<comment><USER21> Your recommendations are a little off in the following ways:

You should use /usr/bin/env bash for the shebang. Some distros, such as nixos, don't have /bin/bash.

You need more quoting in the dirname line. cd "$(dirname "$0")" is what you need. The outer quotes are in case the directory has a space or special character in it, the inner ones are in case the script does.

That being said, you may also want $BASH_SOURCE rather than $0, but the reasons behind that are complicated. You may also want to support cases where the script is a symlink depending on what you're doing.

<comment><USER34> Using 'env bash' to find the local path is definitely the way to go. It also supports that occasional case where the user has installed modern bash somewhere in their local path (under their home directory) and finds that rather than the system copy.

        #!/usr/bin/env bash

If you really want a predictable environment I usually go with something like this after the shebang, it supports bash and not-bash shells:

        case "$(readlink /proc/$$/exe)" in */bash) set -euo pipefail ;; *) set -eu ;; esac
        PATH=/usr/sbin:/usr/bin:/sbin:/bin
        \unalias -a

I don't usually cd anywhere unless I need to.

</comment></comment></comment><comment><USER45> Not to be that guy but this is mostly garbage. I suggest simply paying attention and testing. Switches can be a useful part of the tool but they can break things. It doesn't make things better rather it alters behaviors of the shell in sometimes unintended ways. Try some loops with some -eo. If you have a pipe that fails your script you're just ripping the heart and potential out of your script. I think you might just be looking for one-liners. It can be good to catch your failures and try other things vs "woop, damn, nope." Maybe you need things to fail first.

"Quote liberally" \- also ripe. Mind your aPostrophes and Quotes because they do things.

I like writing for me and what I need done, not what or how others might have me write or how others might think it should be done.

The shell is a base orchestration and interface tool for your os. If you think it's just that bad then just stick to your language of choice but please refrain from suggesting lazy habits make a better shell, they don't.

Fly your own kite. It's much more fun.

<comment><USER45> Ok, "garbage" may have been harsh but how about a fun example? Try this with and without -e

      #!/usr/bin/env bash

      bell=`tput bel`
      tock='Blastoff!'

      do_ring()
      {
        if [ "$1" ]; then # true
          echo -n $bell; sleep 0.1
          echo -n $bell; sleep 0.1
          echo -n $bell; sleep 0.1
          echo $tock
        else
          echo -n $bell; sleep 0.1
        fi
      }

      i=3
      while [ "$i" -ge "0" ];
      do
        if [ $i = 0 ]; then
          sleep 0.5
          echo ok
        else
          echo $i $bell
          sleep 0.5
        fi
        i=`expr $i - 1`
      done

      do_ring $1 # do something different if arg
      sleep 1
      echo neat.

Semantic qualities aside there is something here that breaks with -e and if you're used to using -e by default you might be baffled and think shell sucks, for example.

<comment><USER23> That's why nobody uses expr for arithmetic. But yes, it is annoying that -e breaks some habits that work fine without it.

<comment><USER45> I can appreciate the quip, especially given my curmundgeonly entry. But the point remains. The shell needs to be able to call any command on the system reliably. Even aged old counting methods. At no point in that loop would the expr subprocess return other than zero. Try to break out of that loop with that bash switch.

One should not rely on these magics, the ones that alter runtime behaviors, without truly understanding what you're after and what you're writing. Or mostly understand. They're fine and good if you have narrow routines with a very strict focus - "I'm in, I'm out, bang."

The best switches available to the shell without a bunch of feature and package and library this or that bloat are exactly

      -x
      -n

That's all that you need to ensure that your scripting is what you need it to be. Introduce the magic after you've written the thing. When it's ready and it passes your tests then test it again.

Every single utility and package on that system is at your fingertips. Demand accuracy. I do.</comment></comment></comment></comment>


* is Unix - <AUTHOR> http://jacobian.org/writing/star-is-unix/

<comment><USER3> This meme is a silly amateur-hour wheel re-invention and ignorance of history.

The fact is, pre-forking a pool of processes without implementing a per- process multiple-connection event mechanism is going to be grossly inefficient in terms of memory utilization (ie, you need to use select, poll, kqeueue, etc.).

You can claim otherwise (COW pages et al), but history is not on your side (look at the scalability of existing pre-fork/connection-per-process network daemons). Think about it -- how much of the runtime can truly be shared across connection handlers?

The fact that this model doesn't scale is not news. It doesn't require rediscovery. It shouldn't be surprising. Anyone who has run Apache, sendmail, or any 80s/90s networking software -- much less authored something similar -- will know better.

Moreover, there's _nothing wrong with threads_ \-- threads are a low-level tool that can be used to implement high-level concurrent systems. They're cheaper than processes because they _do_ support mutable state where it's useful, but _you don't have to use fork() to avoid avoid mutable state_.

If you don't want shared mutable state (and you don't), then _don't use it_.

<comment><AUTHOR> _This meme is a silly amateur-hour wheel re-invention and ignorance of history._

Yeah, well fuck you too.

As it turns out, I _am_ an amateur, at least when it comes to POSIX, but more importantly _I find this stuff fun._ I hadn't realized that having fun and learning about new topics was such an offensive thing to do.

Maybe this is just frivolity, but it's surely a better way to spend a few minutes than crapping all over somebody else's fun.

<comment><USER3> My intention was to elucidate why the fork(2) non-event-based "mini-meme" is known dead-end.

<comment><USER4> Off-topic but...we need a proper computer science/programming collection of papers, books, etc. built up so that people can go off and learn things from the past instead of learning about them independently and then spawning blog posts about it.

<comment><USER5> For learning this side of Unix, I've found the following very helpful (note that this is a bit BSD-centric):

1\. _The Unix Programming Environment_ by Kernighan and Pike. The best overall intro to the pipes, shebangs, and other assorted command line stuff in Unix. Very old school, but still very relevant - those are the root of many of Unix's strengths. (K&P's _The Practice of Programming_ is also excellent, though not as specific to Unix.)

2\. _Advanced Programming in the UNIX Environment_, 2nd ed., by (the late) W. Richard Stevens. This and man pages will go a long way.

3\. The man pages themselves. It's generally understood that OpenBSD's man pages are particularly well written, but if you're using Linux and the GNU userland, there will be lots of differences in the details.

4\. The 4.4BSD "Programmer's Supplementary Documents" (PSD) - This is a collection of papers and man pages. While some are out of date, and some are mainly of historical interest, the introductions to tools such as make, lex, yacc, gdb, etc. are quite good, and often a tenth the length of the corresponding O'Reilly book. (These papers may be installed with your distro. OpenBSD has them in /usr/share/doc . I bought the book used for a couple bucks.) There are also "User's Supplementary Documents" (USD) and System Manager's Manual (SMM) collections, with papers on configuring sendmail, using vi, etc.

5\. _The Art of Unix Programming_ by Eric S. Raymond - I recommend this one in spite of finding ESR _incredibly_ irritating. It's a very good conceptual overview of the big design ideas in Unix and their ramifications, albeit one interspersed with narcissistic soapboxing by the author.

In general, using a Linux distro with a strong emphasis on having a friendly GUI layer can keep you at arms length from really learning Unix. Dig around in /etc. Learn to use cron and ed. (No, really.) Get your hands dirty.

I would also highly recommend learning a scripting language that integrates well with C (some people like Perl, Python, or Ruby, I prefer Lua), because really using Unix well is going to involve some C. Working with C isn't scary unless you're trying to build a large system in C - try instead to break it up into a suite of smaller programs, rather than one monolithic one. Take advantage of pipes and all the other existing Unix infrastructure. It's there to help keep complexity at bay.

Mostly, though, tinker and explore.

<comment><USER3> For Unix systems-level/network programming, I'd also add to the list:

1\. UNIX Network Programming: Networking APIs: Sockets and XTI; Volume 1 (W. Richard Stevens) - the books is considered the bible of the BSD networking APIs, and if you're interested in writing network software at any scale, in any language, you should start with this book -- everything else builds from here.

2\. Write Great Code: Volume 1: Understanding the Machine (Randall Hyde) - <USER2> the end of the day you're writing code that will execute on a machine. Understanding how the machine works will help you understand your code.

3\. The Design and Implementation of the FreeBSD Operating System (Marshall Kirk McKusick, George V. Neville-Neil) - If you've ever wondered how copy-on- write pages work (some of the magic behind the fork(2) model), or how your processes get scheduled, this is a good place to start -- even if you aren't using a BSD, the tenants hold.

</comment></comment></comment></comment></comment></comment><comment><USER6> I love an in-depth, technical blog post as much as anyone, and kudos to Ryan for dissecting Unicorn, but I didn't know whether to laugh or cry when I read that Unicorn has, "teh Unix turned up to 11". zOMG! fork!

This series of blog posts underscores my point that the Rails community, perhaps the Web 2.0 community at large, is just now learning things the rest of us have known for years. accept(2)-based pre-forking socket servers are not news.

<comment><USER5> > "teh Unix turned up to 11". zOMG!

Yeah. Ruby people suddenly feeling all hardcore after touching Unix syscalls for the first time. Ick.

</comment></comment><comment><USER7> The alternative to preforking is select(2), which lets you get away with a single-process server and avoid IPC in certain scenarios: <http://www.lowtek.com/sockets/select.html>

I think Boa and thttpd use select instead of forking for clients.

<comment><USER5> You might want to look at libevent (<http://www.monkey.org/~provos/libevent/>) and libev (<http://software.schmorp.de/pkg/libev.html>). They're wrappers to kqueue (on BSD) and epoll (on Linux), both of which improve upon select ([http://www.monkey.org/~provos/libevent/libevent- benchmark.jp...](http://www.monkey.org/~provos/libevent/libevent- benchmark.jpg)).

<comment><USER8> Libevent is great for multiplatform code. PyEvent is the Python wrapper module for libevent also written by dugsong.

</comment></comment></comment><comment><USER9> nginx is Unix

It's obviously designed by Unix orthdoxes and it shows

No dynamic linking! No threads! Not much of mem alloc, either!

</comment><comment><USER10> No. * is most definitely not Unix. Unix is Unix. Anything else is not Unix.

<comment><USER11> Sometimes it pays to click through to the article before commenting.</comment></comment>


State of the Union for MySQL storage engines - <AUTHOR> http://www.anchor.com.au/blog/2012/05/state-of-the-union-for-mysql-storage-engines/

<comment><USER2> Light on details.

InnoDB can be really really slow if you have random keys e.g. [http://stackoverflow.com/questions/9819271/why-is-mysql- inno...](http://stackoverflow.com/questions/9819271/why-is-mysql-innodb- insert-so-slow)

And there's no mention of TokuDB <http://www.tokutek.com/products/tokudb-for- mysql/> which is massively worth investigating</comment>


Seagate FireCuda Compute Harddisks: SMR with PMR Heads/Media? - <AUTHOR> A few weeks ago, I read an article at StorageReview (?) that the 2,5 inch Seagate FireCuda Compute hybrid disk drives are not using  the classic PMR technology but Shingled magnetic recording (SMR). Initially however Seagate has stated that it is PMR in their tech specs.
In late November 2016 they updated their documentation at: http://www.seagate.com/www-content/product-content/seagate-laptop-fam/laptop-sshd/en-us/docs/100802299d.pdf
Quote of the Changelog for Revision D of the tech spec:
page 5: Add MTC bullet & change Perpendicular recording to SMR"
So I checked out all pages just to find on page 8 ( Recording and Interface Technology)
Recording method: Perpendicular
Surely they wrote in the changelog that they changes Page 5, so let's see what they wrote on page 5:
• Shingled magnetic recording with perpendicular magnetic recording heads/media.
Wait - What ?
Does that mean that Seagate can classify every SMR Drive as PMR now ?
This is pretty serious as there are still issues with using SMR drives on Linux Kernels higher that 3.19  (Search for: Seagate Archive 8TB HDD and Linux).
Also it would be far more transparent for the buyer to know that SMR drives are having hard times getting large write jobs.
Does anyone with more technical depth with ("SMR" vs. "PMR" vs "SMR on PMR Heads/Media") can clear these things up ? <comment><AUTHOR> Hmm. I just saw that Seagate "Mobile HDD" 2TB hard drives are also SMR drives, but Seagates specs says: PMR

[http://www.anandtech.com/show/10042/seagate-2-5-inch-2-tb- hd...](http://www.anandtech.com/show/10042/seagate-2-5-inch-2-tb-hdd-smr) versus [http://www.seagate.com/www-content/product- content/seagate-l...](http://www.seagate.com/www-content/product- content/seagate-laptop-fam/mobile-hdd/en-us/docs/100775165c.pdf)</comment>


Anders Hejlsberg - Where are programming languages going? [video] - b-man http://blip.tv/file/1317881

<comment><AUTHOR> This is from 2008

<comment><AUTHOR> To the person that downvoted this, posts that are not new content are generally denoted in the title. Since that was not done, I did it here.

</comment></comment><comment><USER2> \- "Get a Mac!"

\- "Yeah I know."

At least he has a sense of humor :D

</comment><comment><USER3> Could anyone provide a tl;dr summary of the talk?

<comment><USER4> Multiparadigm will be the paradigm of the future. Dynamic and compiled languages will start to look like each other. There will be more functional programming. There will be more declarative programming. Tools will get smarter about finding and exploiting fine-grained concurrency when freed up by more abstract, declarative, functional code.</comment></comment>


Do you smoke test? - <AUTHOR> http://samsaffron.com/archive/2013/02/22/do-you-smoke-test

<comment><USER2> The thing missing from this setup for me is a ramp up of changes on release, and automated rollback based on service metrics/KPIs.

Don't release to the world. Release to 1%, then 5% then 20%... and so on. And if the load time starts going up, or the # errors start going up, or numerous other things - last release gets rolled back and alarms ring.

That way I don't break the world - I break a much smaller N% of the world that demonstrates the problem - which then promptly gets rolled back by the friendly neighbourhood release bots.

I write sucky code - so I write tests to help drive my design and catch errors.

But tests are code too - and I write sucky code - so I write release processes[1] they help save me when I write sucky test code.

If you do continual delivery you _need_ that second layer of metric-driven tracking of release quality or writing sucky test code will catch you out at some point ;-)

[1] and yes - the release ramp up / roll back code is potentially sucky code also - but it's just one bit that does one thing so gets tested a lot more than all the new sucky code I write ;-)

<comment><USER3> That is awesomely cool but a lot of work to setup. For smaller companies not worth the effort.

<comment><USER4> > not worth the effort

Until it is, of course. Growing up is hard.

</comment></comment></comment><comment><USER5> > You only get to see the "real" page after a pile of JavaScript work happens.

Fix that. If you can't test your config and your authoring by crawling server- rendered documents, others can't crawl them either, and they aren't really part of the World-Wide Web.

<comment><USER6> Googlebot executes JS now (has for a couple of years, I believe), and let's face it, it's really the only crawler that matters.

<comment><USER7> Would you happen to know what they're using to do that now?

<comment><USER8> Googlebot is Chrome, more or less.

</comment></comment></comment></comment><comment><USER9> Perhaps I'm missing the point, but I'd be wary of advocating pure automation as a replacement for a good old-fashioned manual eyeballing.

The point of a smoke test is that for all your care in testing and deployment, you still might have missed something. Stuff goes wrong, and not always in an immediately machine testable way. You don't need a full QA department, you just need to open up the bits you've changed after a deploy and have a play to make sure nothing's obviously out of place. It's a small step to make a non- optional part of your process and it has a potentially huge payoff.

Adding the automated integration test is a great thing to do, but complementing it with a human is even better.

</comment><comment><USER10> > This is my fault, its 100% my fault.

> Often when we hit these kind of issues, as developers, we love assigning > blame. Blame points my way … don't do it again … move along nothing more to > see.

I have never found this to be a constructive 'culture'. Instead of placing blame on others or feeling guilt myself, I try to see if there's a way of improving the process itself instead of relying on people not fucking up. Because that's going to happen to everyone. Bugs are still going to happen, but if the process (be it deployment, testing/QA, dev, w/e) eliminates potential points of failure, they will be less frequent and hopefully less severe.

<comment><USER11> Same here, I find that approach often poisonous, embracing and eliminating the suck is far more productive.

</comment></comment><comment><USER3> So you didnt run your selenium tests / phantom tests against your staging environment before deploying to production?

That is testing 101...

Having a smoke test is still usefull because often you dont want to wait for those automated test to complete.

</comment><comment><USER12> Don't get me wrong, I get that PhantomJS and CasperJS are nice. But isn't it an issue that you're only actually running your tests on one engine? That's the cookie that keeps me with Selenium; although I'm eager to try out Browserling as well :)

</comment><comment><USER13> Isn't that what QA is for? My team is lucky enough to have a dedicated tester that has to approve every build in test and staging before we're allowed to deploy to production. It can be a pain but it does catch a lot of sloppy code.

<comment><USER14> I wonder what this does to the mindset/culture of the team knowing that "the tester will catch it". Does this lead to lots of sloppy code that the tester now _has_ to catch? Vs not having the tester and having a mindset that "I better make sure my stuff works". Obviously there's a balance that must be met, but this is something we've debated at my current job. Thoughts?

<comment><USER15> I think people are going to try to avoid the tester experiencing errors. Why would anybody write something badly if it's just going to come back to them in a couple of hours as wrong? But any half-decent culture is probably already thinks this way.

</comment></comment></comment><comment><USER16> Good to know we will let you go this time. Next time you will be required to remove the Facebook login.</comment>


Confusing Terms in Container Ecosystem - <AUTHOR> https://krsoninikhil.github.io/2019/04/05/confusing-terms-in-container-ecosystem/ <comment><USER2> Confusing article. Would've preferred to just see a dictionary of terms and definitions.

<comment><AUTHOR> Thanks for feedback. I'll update it to make it more clear. When I was reading on these terms, a single line description did not help much. A simple dictionary would've been kind of similar. Any specific suggestion, you would like to make?</comment></comment>


[dead] Linkedin's Profile Match Exploit - <AUTHOR> http://uncodeeval.posterous.com/really-linkedins-profile-match-exploit

<comment><USER2> The post just went password protected - but it was about LinkedIn exposing the id's of matches in their source code which could then be added to a standard URL to view the profile.

Basically circumventing paying them $99 for some pro service.

Given that the site seemed to be from a competitor, it felt a bit scummy, e.g. "Hey, here's how to rip off the leader in our field!"

</comment><comment><USER3> Basically, it's:

1\. Go to the "Profile Matches" offer tab

2\. View source; the users' ids are right there

3\. Look up those users' profiles directly (e.g., /profile/view?id=xyxyxyxy

</comment><comment><USER4> I get this:

This site requires a password for access. Unless you select "Remember me on this computer", you will be logged out of this site when you close your browser.

The password can be obtained from the site owner.

</comment><comment><USER5> When I click through to the Posterous site, I see:

""" This site is password protected

This site requires a password for access. Unless you select "Remember me on this computer", you will be logged out of this site when you close your browser.

The password can be obtained from the site owner. """

So I'm flagging this story.

</comment><comment><USER6> "This site is password protected"

No cache available that I can find. The only recoverable snippet:

      We don't usually like bashing on other companies but
      come on LinkedIn! If you're up selling people on $99
      product such "Profile Matches" it'd help to hide the ...</comment>


How did the popular 'Proposition HN' idea turn out? - <AUTHOR>

Here's a link to the original thread:
https://news.ycombinator.com/item?id=5037694
It has been a couple months, how did things turn out?
Are any MVPs finished? <comment><USER2> Here's his update from February: <http://hnproposition.blogspot.com/></comment>


Show HN: Bootstrappers.io – A community for business bootstrappers - <AUTHOR> http://www.bootstrappers.io/

<comment><USER2> Remove the unsafe package asap, and do database operations the safe way.

edit: For downvoters, the author has the 'development mode' package still in the project which allows you full read/write to the database without any credentials from the web console. All that is necessary is for someone to guess the name of one of the collections.

<comment><USER3> What made you say that? Maybe it's changed now but I don't think the site had that package? Were you able to modify content through the browser console?

</comment></comment><comment><USER3> I'm the main maintainer of Telescope. Great use of the app! I'm always excited to see a Telescope site make the front page of HN :)

<comment><USER4> Out of interest, can Telescope do standard paging rather than "endless mores"?

<comment><USER3> No, because "standard" paging doesn't work well for real-time apps (or even non-real time, imho. Anyway it's a complex topic…).

That being said, Telescope's pagination is reflected in the URL. So if you page 4 times and you refresh the page, you won't lose your place.

</comment></comment></comment><comment><USER5> Do you guys have a different audience/different emphasis than bootstrapped.fm?

Either way, I saw some interesting links there. Thanks and best of luck!

<comment><AUTHOR> The audience we are targeting is very similar to Bootstrapped.fm. However, the type of community we aim to build is somewhat different: we want to be the Hacker News for bootstrappers, the site you go check on a daily basis to get the latest news of the community. Bootstrapped.fm discussions are a bit more forum-like.

</comment></comment><comment><USER6> Hey Nick, cool to see one of your projects pop-up! I've been wondering what you've been up to.

A bit of feedback—Unfortunately, it appears that the site is continuously loading. I'm sure its because you're on the front page.

Also, having the user manually add callbacks for Twitter seems odd.

<comment><AUTHOR> Hey Sam,

I did a few fixes that should enable the loading of the site. Wasn't expecting 10K+ page views in a few hours. I will look into the Twitter issue.

Thanks for the feedback!

</comment></comment><comment><USER7> One thing I like about the way subreddit's pages are is they often have a sidebar wiki that contains a recommended book list, some recommended reading, beginner tutorials, related communities and forums etc.

It might be a good idea to add something similar, just an idea.

<comment><AUTHOR> Great idea. Any specific ressources you are thinking about?

<comment><USER4> There are loads of classic startup / lean books out there. You could monetize those with amazon affiliate links.

<comment><USER7> That's a great idea! You could pay for server costs with that, I doubt you could make a lot of money doing that though.

</comment></comment></comment></comment><comment><USER8> There's also this: [http://discuss.bootstrapped.fm/](http://discuss.bootstrapped.fm/)

</comment><comment><AUTHOR> I'm looking for moderators of the community. Please reach me at nick.hould [@] gmail.com.

</comment><comment><USER9> First: Thanks for creating this!

Second: IMHO, I really do think this suffers from being a single page app. It's essentially an HN clone. Would HN be better if it was a single page app? No, it would probably be worse.

<comment><USER3> Telescope creator here. You're not wrong, there's definitely some downsides to Telescope being a single-page app. The two big ones are a longer initial loading time, and making it harder to cache the app.

That being said, there are also advantages: for example, once the initial load is done, the next page loads are pretty much instant.

In any case, I'm hoping that Meteor eventually implements server-side template rendering. When that happens, Meteor apps like Telescope will in theory benefit from the advantages of both static and single-page apps.

</comment></comment><comment><USER10> Love it! Only gripe is the plaintext HTTP login form. Any plans to support HTTPS?

<comment><AUTHOR> Thanks for the feedback! It's in the plans to add HTTPS support.

<comment><USER11> Sorry guys, but there is no excuse not to use https at this day and age. No SSL no dice.

Other than that I'd be super interested in your site :)

</comment></comment></comment><comment><USER12> Not sure why but for me (Mac/Chrome) the page keeps jumping to the top every 5 seconds when I'm viewing a comment thread on Bootstrappers.io

<comment><AUTHOR> Will dig into this. Any other persons experiencing this issue? The project still might have a few glitches. By the way, thanks for the feedback.

<comment><USER13> I'm getting this on Chrome/Mac too. And like everyone else said, great site!

</comment></comment></comment><comment><USER14> Does it have a lag or admin approval on the stories, i just posted a blog post and it does not show.

<comment><USER14> its just popped up :-)

</comment></comment><comment><USER15> Nice site Nick. I am learning meteor these days. Good use of the Telescope application.

<comment><AUTHOR> Thanks for the feedback.

</comment></comment><comment><USER16> Not sure, I believe HN has choked the site? Trying to register and hangs.

<comment><AUTHOR> Should be fixed. My current setup doesn't really support the load of HN + ProductHunt

</comment></comment><comment><USER17> Awesome job Nick! I've been meaning to get into Meteor.

<comment><AUTHOR> Thanks for the feedback Enrique.

</comment></comment><comment><USER18> Looks interesting :)

What did you use to build site?

<comment><USER19> Looks like it is built on Meteor.js. Has anyone used Meteor.js in production? What are some of the cons to watch out for?

<comment><USER3> There's quite a few production Meteor apps. One of my favorites is [https://respond.ly](https://respond.ly).

There are a few more examples here: [https://www.meteor.com/gallery](https://www.meteor.com/gallery) (although that page seems a little out of date)

<comment><USER20> [http://spotting.meteor.com/](http://spotting.meteor.com/) by design will be more up to date.

</comment></comment></comment></comment><comment><USER21> Getting spammed by a 4channer</comment>


Show HN: Todo+, a powerful extension for managing todos in Visual Studio Code - <AUTHOR> https://github.com/fabiospampinato/vscode-todo-plus <comment><AUTHOR> Author here, I'll be happy to answer any question about the project :)</comment>


Marijuana helped shrink one of the most aggressive brain cancers - <AUTHOR> http://www.washingtonpost.com/posteverything/wp/2014/11/18/how-pot-helped-shrink-one-of-the-most-aggressive-brain-cancers/ <comment><USER2> I'm surprised Huffington Post isn't blocked from HN. It's nothing but blogspam and cranks. How about we list the original content, either the study[1] or the op-ed that most of the content was taken from[2].

1: [http://mct.aacrjournals.org/content/early/2014/11/12/1535-71...](http://mct.aacrjournals.org/content/early/2014/11/12/1535-7163.MCT-14-0402.abstract)

2: [http://www.washingtonpost.com/posteverything/wp/2014/11/18/h...](http://www.washingtonpost.com/posteverything/wp/2014/11/18/how- pot-helped-shrink-one-of-the-most-aggressive-brain-cancers/)

<comment><USER3> > I'm surprised Huffington Post isn't blocked from HN.

It used to be, but somebody pleaded the case that they occasionally have solid articles, so we moved it from banned outright to lightweight, which means the articles get penalized by default but various conditions can override the penalty. A lot of big media sites are in this category. It's not a perfect solution, but it works better than the alternative.

In the case of specialized technical papers that aren't in the local sweet spots such as computing, HN tends to prefer the best popular article on the subject, with the paper linked to in comments. It's not a fixed rule but it works well. For that reason, we wouldn't replace the Huffpo url with [1]. However, [2] is clearly a more original source, so we'll swap Huffpo out. Thanks!

(Submitted url was [http://www.huffingtonpost.com/2014/11/18/marijuana-brain- can...](http://www.huffingtonpost.com/2014/11/18/marijuana-brain- cancer_n_6181060.html.))

<comment><USER2> Thanks for the explanation. I've highly critical of HP but you're right, occasionally they have original content that deserves a link.

</comment></comment></comment><comment><USER4> OK. But it isn't marijuana "itself" that does this. It is one or more chemical components that we can isolate, right? We've done so many times before and created more potent medicines.

But just because these components are present in marijuana I can almost bet that it will be reduced to an argument in the fight for legalization of smoking weed.

I'm not saying it shouldn't be legalized (perhaps it should, perhaps it shouldn't), but that it's an entirely different question.

<comment><USER5> _" OK. But it isn't marijuana "itself" that does this. It is one or more chemical components that we can isolate, right?"_

Correct. The study tested two cannabinoids isolated from marijuana, not whole- bud marijuana.

 _" But just because these components are present in marijuana I can almost bet that it will be reduced to an argument in the fight for legalization of smoking weed."_

Well, yes, it's going to go there eventually. Pretty much all conversations about the medical efficaciousness of marijuana (or marijuana-derived compounds) bump up against the legalization topic. This is because conducting research on a substance currently deemed illegal by the federal government is very difficult. It's also because the government labels marijuana not just illegal, but a drug "...with no currently accepted medical use and a high potential for abuse." (This is the 'Schedule I' classification).

Marijuana's classification in Schedule I, a category for "the most dangerous drugs of all the drug schedules with potentially severe psychological or physical dependence," is ridiculous. For what it's worth, here are some drugs legally considered _less_ dangerous, or psychologically and physically dependence-forming than marijuana: cocaine, opium, methamphetamine, oxycodone, morphine, codeine, fentanyl, Dexedrine, Adderall, Ritalin, Vicodin, Valium, Ambien, ketamine, and anabolic steroids.

 _" I'm not saying it shouldn't be legalized (perhaps it should, perhaps it shouldn't), but that it's an entirely different question."_

Absolutely. Marijuana's legalization as a consumer item has little to no bearing on this finding, or vice versa. That said, its current medical status is in debate, and whenever a potential medical usage comes up, that topic is going to come up with it.

<comment><USER6> Doesn't the whole "...with no currently accepted medical use" part automatically obsoletes with research such as this?

Surely the DEA has a mailing address to which it's possible to send relevant research papers?

Surely they read the literature?

<comment><USER7> I honestly can't tell if you're being earnest or not. So, apologies if you're being sarcastic.

The DEA, as a government agency, was created with the mission of eradicating drugs. They aren't really in the business of doing scientific evaluation of the drugs themselves, and I would be surprised if there are any scientists on staff, and if there are, even more surprised if they have any pull.

At any rate, the DEA doesn't set drug policy, the federal government does.

The federal governments' track record when it comes to controlling substances has not often been in line with scientific or social needs, as is evidenced by the extreme cost of the current war on drugs and the consequent negative effects on society. For example, cocaine is a refinement of cocoa which was included in things like coca-cola as a mild stimulant. When it became controlled, smuggling economics came to bear, and thus refining it into cocaine allowed for more value-per-unit-shipment in smuggling. Being more addictive, and thus worse for society, was a side effect of this. Worse, with the war on cocaine that occurred an even further refinement was done for the same economic reasons resulting in crack.

I posit that if the wellbeing of society were the primary importance for the federal government there would be no drug war, and thus no drug related violent crimes (or very few) and a lot less addiction.

<comment><USER6> Thanks. It just seems to me "currently accepted medical use" is pretty unambiguous, there is SOME, that is, other than none, currently accepted medical use so their definition is wrong on its face. I'm surprised that nobody told them "Look, you're using English wrong(ly)" as a way to challenge the law.

English has a simple grammar to figure out, but things like this remind me why it's a difficult language to truly grok.

(I am Italian. Our government does occasionally do things like this, but at least they have to employ four paragraphs of byzantine quasi-latin, not get away with five words of non-language).

I mean, if some words are in a law that causes public expense, arrests, killings, etc. I would say it's pretty important that their meaning is set in stone and universally understood! I suppose there are problems with the US Constitution in that sense, but in this case the language used is current, not 300 years old.

<comment><USER5> _" Thanks. It just seems to me "currently accepted medical use" is pretty unambiguous, there is SOME, that is, other than none, currently accepted medical use so their definition is wrong on its face. I'm surprised that nobody told them "Look, you're using English wrong(ly)" as a way to challenge the law."_

Their classification of marijuana as having "no accepted medical use" is silly on its face, and I hope I adequately gave that impression in my comment. I'm not agreeing with it. I'm just pointing it out.

Unfortunately, changing the DEA's opinion is harder than just sending them the medical literature, and pointing out the contradictions in their position. This is a problem that needs to be addressed through the legislative process. (The DEA follows federal policy; it doesn't necessarily establish or alter federal policy). Fortunately, change is happening at the state level. If we reach the point where most states recognize medical uses for marijuana, then eventually, the federal government will have to cave on its hard line. Or so the thinking goes.

English is indeed a complex language, and it's also filled with the sorts of loaded terms with which lawyers have a field day. For instance, consider the word "accepted" in the phrase "accepted medical use." Accepted by _whom_? Who decides whether to officially "accept" a medical use? Is it the DEA? Is it the medical and scientific community? Is it the legislative branch of the federal government? Is it the judicial branch? Is it someone else? If this issue were ever to come to court, the DEA could argue that there is no "accepted" consensus. It would be a weaselly argument, but English is a fantastic language for weaselly, semantic arguments like that.

</comment></comment></comment></comment></comment></comment><comment><USER8> My mother died of an agressive blastoma multiforme last spring. I tried to get her cannabis but she declined in spite of the evidence I presented (at the time the principal papers were written in Spain). Marijuana use has been greatly stigmatized in my country and that played a big role in her rejection. I am both glad and angry at the same time.

<comment><USER9> Sorry to hear about your mother. I have talked my father into investigating therapeutic use of cannabis for his Parkinson's. He indulged as a young man but the war on drugs and raising a family put a kibosh on recreational use for him years ago. The drug war propaganda has been so effective that he was reluctant to try it despite recent legalization in our home state. In a very unscientific experiment this summer, I watched his symptoms disappear after imbibing a small amount. If only we can get the word out to more people.

<comment><USER10> My father is in the same situation, except MJ is not even available medicinally. Could you tell me what form your father ingested? Was it high-CBD edibles, or what?

</comment></comment></comment><comment><USER11> Two parts of the Huffington post submission here clarify the issue:

"In a paper published Friday in the journal Molecular Cancer Therapies, a team of researchers from St. George's University of London outlined the "dramatic reductions" they observed in high-grade glioma masses, a deadly form of brain cancer, when treated with a combination of radiation and two different marijuana compounds, also known as cannabinoids. In many cases, those tumors shrunk to as low as one-tenth the sizes of those in the control group."

So the tumors are being treated with radiation in the current study, as well as with cannabinoids.

"Liu and his colleagues examined mice that had been infected with glioma and subsequently treated with radiation alone or in combination with varying levels of two cannabis compounds: THC, the psychoactive compound associated with the "high" sensation, and CBD, which doesn't produce psychoactive side effects."

So far this is a study in a mouse model organism, which may or may not generalize to human patients. This is worth looking at further, but the trade- offs of safety and effectiveness for drug treatments of all kinds can often differ between human beings and mice.

<comment><USER12> Nearly all cancer studies use combination treatments. Among other reasons, the cancer cells will adapt to single treatments rapidly (for example, the treatment will kill all but a small population, which is immune to the treatment, and that population will expand).

</comment></comment><comment><USER13> Will there be a time when a majority look at how we have stigmatized and prevented marijuana use so vocally and with such dire criminal consequences when it could have been used to help in the proper channels?

I strongly believe a lot of science is not done on marijuana because of the vocal critics or the fear of vocal critics. Just in the US, certain people can be pretty vindictive when it comes to their causes.

<comment><USER14> >I strongly believe a lot of science is not done on marijuana because of the vocal critics or the fear of vocal critics.

That appears to be changing for the better. The most important thing is to somehow make sure that non-physicians and non-scientists such as the DEA are removed from the decision making process (of what gets studied, and of drug scheduling).

>Just in the US, certain people can be pretty vindictive when it comes to their causes.

I hope that it isn't vindictiveness. I've always assumed that it is either an inability to sympathize, or an indifference to other peoples' suffering; also, ignorance.

</comment></comment><comment><USER15> Terence McKenna smoked marijuana for 35 years heavily. He died of brain cancer.

 _McKenna was diagnosed with glioblastoma multiforme, a highly aggressive form of brain cancer. For the next several months he underwent various treatments, including experimental gamma knife radiation treatment. According to Wired magazine, McKenna was worried that his tumor was caused by his 35 years of smoking cannabis, although his doctors assured him there was no causal relation._ -Wikipedia

<comment><USER16> Smoke anything for 35 years and you're running the risk of serious health complications. Smoking cannabis for medical reasons is nonsensical.

<comment><USER17> That's probably not true. If you don't have the time, expertise, or space to legitimately cook something in it with whichever components of marijuana are utilized in the cessation of nausea or pain, and you can't afford/don't have the time to go get/are not near a place where they sell a vaporizer then smoking is your best option. And recent research has suggested a litany of positive effects for those suffering from a variety of ailments.

In this case, smoking would be quite sensical not only because it will make you feel better. Stress is a known killer, symptoms such as nausea (and it's side effect known as 'not being able to eat') or pain increase stress. Ergo, it can be quite easily seen that there are many instances where a person would be quite sensical in choosing to smoke marijuana instead of continuing to suffer, negative side effects of smoking marijuana included.

This of course does not go into the debate of marijuana versus addictive opiates or more "traditional" forms of medication which opens up an additional set of conversation topics, many of which conclude that marijuana is more than likely to be preferred over traditional forms of Western medication.

<comment><USER16> Obviously if given no other choice, smoking cannabis might be a viable option. It's important to keep this discussion in the context of the parent comment, which was pointing our (rather anecdotally) that some guy who smoked cannabis for 35 years died of cancer (implying that the assertion made in the parent article was incorrect or flawed).

</comment></comment></comment></comment><comment><USER18> Now maybe we can extract the active ingredients and make a better, more effective therapy with fewer side effects, instead of making people damage their lungs smoking a weed to get this into them, or making them eat fatty foods and damaging the rest of their bodies.

</comment><comment><USER2> Anyone have a source that explains the mechanism of action behind cannabinoids disrupting cancers?

</comment><comment><USER19> Works really well on skin cancer too.

Vaporize then condense the resins. Apply resin to skin cancer spots sparingly.

<comment><USER20> Wouldn't it work better with oil and also be easier?

<comment><USER19> I don't know. Try it. I just posted what I know from personal experience. The resin definitely works.

[http://www.youtube.com/watch?v=fQwwGPiyW9M](http://www.youtube.com/watch?v=fQwwGPiyW9M)</comment></comment></comment>


Ask HN: Good resource on starting a buseness in the US? - <AUTHOR> Could you recommend a good book or a website that goes into all the small details of starting a small business in the US? (SAAS platform)<p>Basically I want to find out how to choose between LLC/different types of corporations, how to do accounting, file taxes, deal with IRS and all the other mundane stuff that goes with running a business. <comment><USER2> I like this book: [https://www.amazon.com/Small-Time-Operator-Business- Yourbook...](https://www.amazon.com/Small-Time-Operator-Business- Yourbooks/dp/158979799X)

</comment><comment><USER3> Depends on which state in which you wish to incorporate. It is relatively straight-forward once you decide on a state, as each one has its own way (but they are all very similar for the most part).

Consider forming an LLC in Delaware, as they have the lowest corporate taxes (well known fact, not necessarily important in most cases). Research fun

</comment><comment><USER4> Look at the Small business administration. It's a great please to get started.

[https://www.sba.gov/](https://www.sba.gov/)

</comment><comment><USER5> Can you recommend any accounting firm for Delaware INC company? We started with Stripe Atlas but can't find good and affortable firm.</comment>


Show HN: VisSense.js – Library for observing visibility changes of DOM elements - <AUTHOR> https://vissense.github.io/vissense-demo/

<comment><AUTHOR> You'd do me a great favour if I get some feedback on this project.

</comment><comment><USER2> Looks good :)

<comment><AUTHOR> Thank you. I know that :] ... but it is not all about the looks.

Is it easy to understand/use/integrate? Do you think it is well designed/extensible/developer friendly? Too many questions.. unanswered.

Anyway, thanks for your comment :]</comment></comment>


Ask HN: How will you replace Keybase? - <AUTHOR> I run a small business with a few friends and Keybase has been great for us. It got all that we need: chat with channels, file sharing with a folder structure and git. That it's end-to encrypted* is a great bonus.
Since Zoom announced that bought Keybase yesterday, we are no longer comfortable depending on Keybase and will transition to other services.<p>What are some replacements to the features Keybase offers?<p>*proper e2e, not in the lame way Zoom described its interpretation of e2e... <comment><USER2> So far I've replaced Keybase with:

Association of keys with identity -> [https://keys.pub/](https://keys.pub/)

Git -> Github via git-remote-gcrypt

IM -> Telegram. Not a proper replacement, but works for most of my contacts. Something really secret can be shared via GPG. I guess for your small business a self-hosted Mattermost instance will fit.

Files and directories sharing -> syncthing. I use it mostly between my devices.

<comment><USER3> I've seen keys.pub mentioned a bunch now. Time to check it out, I guess. Sure looks (from a UI perspective) better than the gpa (Gnu Privacy Assistant) I used before: [https://www.gnupg.org/related_software/gpa/](https://www.gnupg.org/related_software/gpa/)

Even though the docs clearly state: "This project is in development and has not been audited."

</comment></comment><comment><USER4> There's been some discussion on this topic here, though a slightly different angle, just for reference - [https://news.ycombinator.com/item?id=23103386](https://news.ycombinator.com/item?id=23103386)

</comment><comment><USER5> I'm probably going to use GNU JAMI as a replacement, as I was already using it to a lesser extent before this debacle

</comment><comment><USER6> Does anyone know of an equivalent product/solution for the cryptographically- linked social media identities feature of Keybase?

Technically the cryptographic links can still be verified even if Keybase doesn't exist anymore, but they did provide a user-friendly interface to set them up, etc.

<comment><USER3> Some minimal open-source tool for the "cryptographically-linked social media identities feature" would indeed be awesome! Would be a shame if all those links ended up being abandoned.

</comment></comment><comment><USER7> Keybase Chat -> Matrix/Riot Zoom -> Jitsi Meet

Both of the above alternatives are end to end encrypted (E2EE)

As for the social keys aspect of Keybase, hope that Keybase open sources their solution.

</comment><comment><USER8> I wish there were a way to tie my existing GPG keys to a keys.pub account.

As it is, I'm probably going to add a well-known to my personal website with my keys.

</comment><comment><USER9> You can get all this by running your own server. The plus side of this is that you will also protect a lot more meta data this way (not all, but more).

On your own server, you can host your own git repos, your own IRC server, and your own file storage.</comment>


10 Years of Web Inspector - <AUTHOR> https://webkit.org/blog/5718/10-years-of-web-inspector/?utm_source=SitePoint&utm_medium=email&utm_campaign=Versioning <comment><USER2> > Ten years ago today we introduced the first version of Web Inspector to the > world. That time was the wild west of web development, when your best > debugging aid was alert(). While the earliest version of Web Inspector was > limited (it didn't even have a console), it did expose two things that > developers didn't have much insight into — the DOM tree and matching style > rules.

The current crop of web inspectors all trace their (spritual) lineage to DOM Inspector, and to an extent, Mozilla's old JavaScript debugger Venkman. Both showed up in 2001.</comment>


Fiat Chrysler Automobiles - <AUTHOR> https://bugcrowd.com/fca <comment><AUTHOR> "We appreciate the high volume of submissions for XSS. We are temporarily removing this vulnerably from scope as we work to fix those issues"</comment>


Computing Fibonacci in RethinkDB - <AUTHOR> http://rethinkdb.com/blog/fib/

<comment><USER2> Slava, why "r.table('fib').orderBy('id').nth(x.sub(1))"? It looks like "r.table('fib').get(x.sub(1))" would be the same behavior but more efficient, using a primary-key lookup rather than retrieving the entire table and ordering by it.

What am I missing? :-)

<comment><AUTHOR> You're absolutely right. (I think what you're missing is that I wrote this at 4am, I'll see if I can write up better solutions soon :))

<comment><USER2> Woohoo, I out RethinkDB'd RethinkDB! :-D

Aside from that detail, this is a cool post. I like seeing the power of ReQL.

<comment><AUTHOR> Also, instead of typing the array manually, I could have just used python's `range` operator. I'll fix that too.</comment></comment></comment></comment>


Squeryl: A concise, type-safe Scala ORM and DSL - <AUTHOR> http://squeryl.org/

<comment><USER2> This seems to be a very promising and well designed project. However, there one part that puzzles me. On the one hand,

 _> SQL's declarativeness is preserved, not encapsulated in a lower level API that requires imperative and procedural code to get things done._

but on the other hand

 _> A significant part of optimizing a database abstraction layer is to choose for every situation the right balance between fine and large grained retrieval, and the optimal mix of laziness and eagerness._

Why is that even relevant? If the possibilities of SQL are preserved, why can't you simply let the database aggregate your data and make it return exactly what you need? ... which will be what you'll send to the user, after some formatting/templating, so the really wanted result can't be too big.

In other words, the difference between fine and coarse grained retrieval only matters if you have a big intermediate result that you have to process aside from the database because your ORM doesn't allow you to do that within the database. Since Squeryl claims to be different in that regard, why does the retrieval strategy even matter?

<comment><USER3> I agree with you in the context of a single table. Introduce something a little more complicated, such as master/detail relations, however, and things aren't so straightforward. The mere fact of a foreign key in the child that the ORM can pull out of DB metadata (or have manually described to it, etc.) isn't enough to know if it's reasonable to be lazy or eager in retrieving child rows when getting the parent.

<comment><USER2> _> I agree with you in the context of a single table._

I actually had complex joins in mind.

A good ORM (in the sense that most ORMs _aren't_ good by this definition) should retrieve the child rows if and only if they are required for the final result. And it should request exactly the columns that are needed by the result. And, as already pointed out in my previous comment, it should hand over the aggregating to the database - that's one of the main things databases are good for.

<comment><USER4> "And it should request exactly the columns that are needed by the result"

Gavin King (the Hibernate guy) argued that all columns should be fetched by default because (A) the marginal cost of doing so is very low once the db has taken the disk hit for any data in the row and (B) an in-memory object cache is easy/efficient if entire objects (rows) are cached at once. I might be paraphrasing a bit much.

One could argue that, when some databases can return a subset of column data from indexes (vs eating the disk hit for the row data) that limiting the columns fetched could be much more efficient.

There are probably very few areas of any app I've worked on where I would have gotten significant performance gains by limiting results to a subset of columns.

<comment><USER3> It depends. If there are a lot of columns and you're only interested in a handful, and there's an index that contains all those columns, it should be much cheaper just to select the interesting columns, as all the data needed can be retrieved from the index. Asymptotically, the size ratio between the columns selected and the columns in the table gives the speedup.

</comment></comment></comment></comment></comment><comment><USER5> Squeryl is really awesome as far as scala-orms go. I've used it in a couple of hobby projects and currently am using it in a bigger, and hopefully revenue bringing, project (a mix consisting of scala, wicket, squeryl and mysql. So far so good!)

Maxime, the guy behind squeryl is also very very helpful. I've posted a few questions on squeryl's group and have never waited more than a day for a reply.

Perhaps it's because squeryl still is relatively unknown, but still, this goes to show that this project at least has a Human Interface which is always nice.

Lastly, hopefully squeryl will get some more attention now that Lift has given it some official attention.

Anyways, yeah. Squeryl. Cheers.

</comment><comment><USER6> Needs a code example on the front page.

<comment><USER7> I was about to post the same thing. Code examples are the second thing I look at when I see the web page for some new library or framework. The first thing I look at is the one-sentence description right below the title, if any.

You may notice that this maps pretty well to how pages on Github are set up. That's because Github has really nice design.

</comment></comment><comment><USER8> Seems decent enough, I should reintroduce to Scala.

The website does not degrade well, though: no JS == no code listings.

<comment><USER2> It also uses a strange apostrophe replacement in words like _won't_ and _SQL's_. That is, it uses an accute accent over a space (') instead of a simple apostrophe (').</comment></comment>


Darpa unveils 'extreme' in-hub electric motors for military vehicles - <AUTHOR> https://electrek.co/2018/07/21/darpa-electric-vehicle-military-applications-inhub-motor/ <comment><USER2> It is very well presented in the video. Even more is discussed. Some of it looks promising.</comment>


Minno Rebrands As BuySimple, Raises $700K For Micropayments - <AUTHOR> http://techcrunch.com/2011/05/31/minno-rebrands-as-buysimple-partners-with-soundcloud-raises-700k-for-micropayments/

<comment><USER2> Cute and all, but not the sort of thing I'd ever want to tie to Facebook. OpenID is preferable, creating a new user name / password is a livable second choice.</comment>


Researchers say Yahoo Mail exploit still active, despite claim of being fixed - <AUTHOR> http://thenextweb.com/insider/2013/01/08/researchers-say-yahoo-mail-exploit-still-active-despite-claim-of-being-fixed/ <comment><USER2> Having worked at Yahoo! and being directly involved with an instance of a few million phished accounts I can only say that they take this stuff very seriously. We had a team of 5 or 6 people working about 2 months to resolve this issue.

When you're the size of Yahoo! it's not just a simple code push. The process of letting users recover their accounts is very tricky.

Anyways, I have plenty of gripes about Yahoo! but how they deal with security is not one of them.

</comment><comment><AUTHOR> For reference, here is the previous discussion: <http://news.ycombinator.com/item?id=5021841>

</comment><comment><USER3> I received an email just yesterday from my sister saying that she clicked on a link in an email and that her yahoo mail account had been compromised ("hacked" were her exact words).

I didn't actually believe her at first but now it all makes sense.</comment>


Ask HN: Mammoth Hacking - just do it? - <AUTHOR> http://ngm.nationalgeographic.com/2009/05/mammoths/cloning-interactive Via http://channel.nationalgeographic.com/episode/waking-the-baby-mammoth-3630/Overview <comment><AUTHOR> Via [http://channel.nationalgeographic.com/episode/waking-the- bab...](http://channel.nationalgeographic.com/episode/waking-the-baby- mammoth-3630/Overview)

</comment><comment><USER2> Mammoth might be _delicious_. How can we know unless we try?</comment>


EFF Got a Copyright Takedown Demand - <AUTHOR> https://www.eff.org/deeplinks/2019/09/time-when-eff-got-copyright-takedown-demand <comment><USER2> Did they really send this email with a spelling mistake in it?

> in our Body Warn Camera page, [https://www.eff.org/pages/body-worn- > cameras](https://www.eff.org/pages/body-worn-cameras),

Warn vs worn

</comment><comment><USER3> The images are VERY similar, so I guess the implication is that the filer of the takedown request copied and tweaked/edited the EFF image?

<comment><USER4> It's not an implication, it's explicitly stated in the article.</comment></comment>


Restoring a 14-year-old website - <AUTHOR> http://www.re-cycledair.com/restoring-a-14-year-old-website

<comment><USER2> It's amazing how many of us shared the same experiences around this time. I suspect you are 31, yes? 1999 was my favourite year in high school.

My website at the time was the Armadatron, which was all things Armada (Sega Dreamcast). It was very similar in design and content, but based on the Armada universe. Players could read it to find where the best star-bases and planets were in the game, etc.

I'm pretty sure the URL was [http://online- resource.com/armadatron](http://online-resource.com/armadatron), but the Wayback Archive redirects that URL to a parked domain. Is there any way to disable the redirect on Wayback Machine?

In a small bit of success at the time, the official Armada devs linked me from their home page :) I used Frontpage Express and notepad and after hosting a different website using my ISP and Xoom, I bought my first domain and real hosting.

That's back when you could only get domains from one company and had to pay for two years by cheque. It took forever, but it taught me many important things about running a website.

I am a web developer, today.

Thanks for the read!

<comment><USER3> [http://web.archive.org/web/20010601000000*/http://online- res...](http://web.archive.org/web/20010601000000*/http://online- resource.com/Armadatron)

Sadly it seems that even the older snapshot is not working, so either that wasn't your url, or the wayback machine got to it too late :(

<comment><USER2> Aw. Seems like you're correct. Darn!

</comment></comment></comment><comment><USER4> Terrific! There's something so raw and human about these old geeky websites. Random people from all over making comprehensive, quality content about the things they love and showing it to the world how _they_ want, through _their_ eyes. Information is cleaner and better organized now, but less personal and less fun for sure.

</comment><comment><USER5> Those 'Enter' landing pages + left menu frames are classics. Good times

<comment><USER6> my proudest achievement was getting 'boxless' frames working that didnt look like shit. all hand-coded

</comment></comment><comment><USER7> Cached (Text-only): [http://webcache.googleusercontent.com/search?q=cache:http://...](http://webcache.googleusercontent.com/search?q=cache:http://www.re- cycledair.com/restoring-a-14-year-old-website)

</comment><comment><USER8> Brings back a lot of memories of old sites worked on in the past... and table layouts abused: [http://www.davidearl.ca/portfolio/](http://www.davidearl.ca/portfolio/)

</comment><comment><USER9> Beautiful. I often try to find some of my old sites. This brings back some great memories, thanks.

</comment><comment><AUTHOR> I apologize friends, I wasn't expecting this much traffic and had just stepped out. Working on getting this back up now.

Edit: It's back up. Sorry for the inconvenience!

<comment><USER10> What are you guys running that site on, out of curiosity?

<comment><AUTHOR> Sorry, my $10 digital ocean vps is kinda struggling. The blog is hosted on WordPress, and being cached via memcache. But GA real time tells me about 300 people are on concurrently which its having trouble handling. I'll be periodically rebooting the box until I can access a computer.

<comment><USER11> 300 concurrent connections? Sounds great. I wish my sideproject was hit with that kind of traffic :) I'd love to see what it takes to crash it :p

</comment></comment></comment></comment><comment><USER6> LOLLLL. I so remember these days. I had several of my own. I think mine was "the best final fantasy 7 website out there!"

Some kid emailed me to call my bluff lol.

I still wish i could find mine, but i remember practically 0 about any of them :'(</comment>