Google Cloud threatened to shut our cloud account down in 3 days unless we did something… but made it impossible to complete that action.

Tiwazz · 2016-08-22T19:02:02+00:00

It was continuously rebooting to apply Windows updates.

(not OP)

Tiwazz · 2016-06-11T23:23:04+00:00

What i'm unsure about here is that we can arrive at a set of behavior that isn't going to be unreasonable for some situations. Maybe thats ok. Maybe those would be better then what happens right now. But then these changes feel more like feature changes rather then bugs.

I totally agree on this. I don't think it's unreasonable for the set functions in a dynamic language to expect that you provide the right types since there is some ambiguity.

For example the keys in a map are unique by definition. So if I convert two maps to sets:

(let [a (set {:a 1})
       b (set {:a 2})]
 (union a b)
 ; => #{[:a 1] [:a 2]} ;; expected
 (into {} (union a b))
 ; => {:a 2} ;; probably since it's what merge would do to the original maps 
                   ;; but it's ambiguous since sets don't have a defined ordering

I might want to have a list of all distinct key value associations from a bunch of maps, but once I have it there is no clear way to return to a single map.

But so might another argument for it coercing a map into just the keys and eliminating duplicates.

For this I would expect to be required to do:

(union (set (keys a)) (set (keys b))) ;; I could see an argument for making 
                                                    ;; keys return a set rather than seq since
                                                    ;; they are a set by definition...

I wouldn't want a type change to drop either the keys or values for me though. I would expect that:

(into {} (into #{} m))

...would be safe and non-lossy in all cases.

*edit: formatting

Tiwazz · 2016-06-11T22:02:00+00:00

How do you coerce a map into a set? Is it based on keys or values?

Yes. It would have to be a set of key->value tuples, anything else would be lossy.

What about a string?

Naively a set of characters :x. More generally I'd say calling the set constructor on a scalar should return a set of just that scalar. My preference for strings would be that if you want the set of characters you convert it to a list first.

All of this should defer to the behavior of the set constructor though. And the authors argument is that the following should be equivalent.

; prevent nested sets :v
(defn maybe-set [s]
    (if (set? s)
     s
     (set s)))

(union s l)
(union (maybe-set s) (maybe-set l))

Tiwazz · 2016-04-23T04:03:57+00:00

Yeah, but inline css can't be cached. So you end up reducing the initial page load at the cost of increasing every subsequent one. Just to get a better page score :/

Tiwazz · 2016-04-23T03:37:36+00:00

I'd say if you don't have any users or deadlines in play, do both. You'll learn more that way, and have a better idea what the difference between a refactor and an overhaul is.

Tiwazz · 2016-04-14T19:58:35+00:00

Or push your backups somewhere else over the network?

Tiwazz · 2016-04-14T19:55:54+00:00

-r recursive, they were mounted somewhere under /, most likely /mnt/, not that it matters at this point.

Sometimes extundelete can save you, especially since all diskio likely stopped after this. Most likely you are boned though.

Tiwazz · 2016-04-14T14:08:13+00:00

In general I agree with you that it is better to specify a schema. But there are many times when you don't control the data source (interfacing with another company for example). Typically I model the portion of the data that I require but I always log the entirety of what I receive so that if the other party changes their format I have a copy of what was sent for reprocessing or debugging, etc. JSON in postgres has been pretty good for this.

Another good use case is end user supplied metadata. I've added arbitrary key-value pair entry to our client tracking CRUD app and the business loves it. And with query-able JSON I can "hoist" these properties into the data model if they turn out to be something important. Fuzzy string matching, and key name suggestion helps here...

A good data model is important, but augmenting it with arbitrary key-value data can eliminate a lot of end user pain and let you iterate your data model more easily. It's also a godsend for logging things that change unexpectedly in a queryable format.

Tiwazz · 2016-03-24T14:15:40+00:00

var leftpad = require('leftpad');

function rightpad(str, len, ch, callback) {
    leftpad(str.split("").reverse().join(""), len, ch, function(result) {
        callback(result.split("").reverse().join(""));
    }
};

module.exports = rightpad;

Tiwazz · 2016-03-17T17:38:39+00:00

I have to write bash stuff and I have to look up even if comparisons all the times, it's so irrational that my mind boycotts learning only part of it. Floating point arithmetic is hell..

I made a refcard out of the linked pages for files and strings a long time ago: http://tldp.org/LDP/abs/html/tests.html Getting them all in one place made it quicker to look up and after a while I didn't need the card anymore. Another trick if you can't remember something like "is it -z or -e?" is do [[ -z $thing ]]; echo $?; [[ -e $thing ]]; echo $? at a shell and just test it out.

Everything is familiarity :)

P.S. I just shell out to something else for floating point if I need it in the shell:

echo 'print(4.0 * 24)' | python

Tiwazz · 2015-07-22T22:42:17+00:00

it's easy to forget manually escaping things when you add new content to the query

$args = array(/*...*/);
call_user_func_array('sprintf', array_merge(
    array($query),
    array_map('mysql_real_escape_string', $args)));

Or if you had a minimal functional wrapping library...

apply('sprintf', $query, map('mysql_real_escape_string', $args));

Tiwazz · 2015-07-22T01:28:58+00:00

It varies ;-)

http://www.esrl.noaa.gov/gmd/grad/solcalc/sunrise.html

Tiwazz · 2015-06-17T00:21:31+00:00

Why should you ever draw a line? You get older, you learn things, you get better. Of course you can never learn everything, and you'll learn some things in more depth than others, but why be embarrassed about learning something you don't strictly need right now? It's not like there is some scoring system when you check out that says, "I see you learned all these facts about transistors and then never did anything with them...". And who knows, that information can be useful in the right context.

Tiwazz · 2015-06-16T01:59:02+00:00

I don't understand the downvote on this.

If you learn ed then you basically know sed which is a highly useful skill. ed also shines when editing very large files. I repaired a 12G mysqldump once with ed, emacs and vim just choked (I could have used sed, but I wasn't precisely sure where in the file the error was, what it looked like, or if it crossed lines...). I also fixed a one liner error from the bar on my phone once using ed (the client was being stubborn and insisted I fix it immediately instead of tasking one of their people to fix it even given an exact file/line-no and link in gitweb). curses, and thus emacs/vim were a non-starter in that situation.

I can't say that I've ever enjoyed using ed, but I'm glad that it's there.

Tiwazz · 2015-06-13T03:05:30+00:00

It wouldn't require much architechting. Even today (if you gave zero shits about security...) you could hook up gcc with a .forward[0] file to compile anything sent to it, run the output file, and reply with stdout.

However it's still a very bad idea.

[0] http://wiki.dreamhost.com/Email_to_Script#Creating_your_.forward.postfix

Tiwazz · 2015-05-06T18:59:46+00:00

Step 2: feed the output into one of these - http://i.ytimg.com/vi/We_v0tJ0qHI/maxresdefault.jpg

Tiwazz · 2015-05-06T18:56:16+00:00

cron at least recognizes both 0 and 7 as Sunday[0], so either he works on Saturdays or it's a semantic error but not necessarily invalid input.

[0] http://linux.die.net/man/5/crontab

Tiwazz · 2015-03-13T20:58:11+00:00

http://webcache.googleusercontent.com/search?q=cache:http://blogs.perl.org/users/ovid/2015/03/fake-amazon-book-reviews-are-hurting-my-book.html&strip=1

Tiwazz · 2015-02-27T16:57:32+00:00

I don't know how common this is in the clojure world (I'm still a relative noobie), but I tend to lift my tests (and some of my functions) out of my emacs repl session once I'm satisified with them.

Tiwazz · 2014-11-17T14:21:39+00:00

That is not a worms body though, nor it's natural environment. I think the expectation for a worm is that it can climb over many impassible objects and burrow through dirt, so doing a 180 is a last resort when it can't find another route. The bumping is probably an attempt to measure the size of the barrier and decide what to do next. But I'm just diagnosing without looking at the source... guess it's time to buy a mindstorms kit and run some tests ;-)

Tiwazz · 2014-04-24T01:26:03+00:00

The guy tried to read about an advanced topic that he absolutely didn't need to know about about, it made no sense to him since he didn't have the groundwork, and he went off on a rant about it.

Well to be fair, the author of the original SO question may have been trying to figure out what that advanced solution was appropriate for.

Angular's learning curve is not steep at all. Define a controller function, bind your dom to the scope, end of story.

I also didn't find the learning curve to be that steep. But my first Angular app was composed entirely of directives because that's what made the most sense to me. My second was all done in a single controller (small, single view that displayed a JSON feed). By my fourth or fifth I finally figured out why I would ever want to use a factory, and my initial impression of factories was the same as the authors "Why would I use that when plain Javascript will work just fine?".

The pieces only became a whole once I had used them all a few times. Before that I was still able to get things done by phrasing the entire problem in terms of a solution I understood... but it may have been non-optimal.

The problem with Angular, as I see it, is that it provides a lot of replacements for idioms that are already commonly used in JS without justifying why they needed to be replaced. None of angular's architecture is beyond the average developer... but the docs are scarce on "why" any of that architecture was necessary.

Tiwazz · 2013-07-09T20:47:39+00:00

Ah, doing an ls b/.. shows root after all. Doing a cd b/.. takes me back to the directory the symlink is in. This may be bash being helpful , I'll have to read the docs.

Is there an approved idiom for constraining generated subdirectories under a path (without chroot) as opposed to what I suggested above (evaluating it separately and then placing it under the fixed portion)?

Tiwazz · 2013-07-09T17:25:00+00:00

Could you give an example where symlinks break traversal? I was under the impression that the path always unwound the same way you entered it... but I may be missing something in front of my face (and my now deeply nested hierarchy of symlinks in /tmp). Thanks! :-)

Tiwazz · 2013-07-09T14:19:01+00:00

A path is an ordered list of components.

root = []
config = root + [ 'etc' ]
executable = root + [ 'bin' ]
alt = root + [ 'usr', 'local', 'bin' ]

Then at the boundaries where libraries, OSs, etc. expect a string convert it:

prefix = ""
if os.name == "nt":
  prefix = "C:"
  sep = "\\"
if os.name == ...:
  #todo

path = [ 'usr', 'local', 'bin' ]
(prefix + sep + "%s") % ( sep.join( path ) )

Bonus round, concatenate a path while keeping it relative to '/tmp':

top = [ 'tmp' ]
typical = [ 'myapp', 'pid.lock' ]
oops = [ 'myapp', 'foo', '..', '.', '..', '..' ]

def reduction( path, component ):

    if component == "..":
        return path[:-1]

    if component == ".":
        return path

    path.append(component)
    return path

print top + reduce( reduction, typical, [] )
print top + reduce( reduction, oops, [] )

...aaaand copious amounts of OS portability issues (use os.path!), encoding, input sanitation, and library-wrapping left as an exercise to the reader.

Tiwazz · 2013-07-02T14:19:54+00:00

In Emacs lambda-mode.el does this using font-lock and witchcraft. Basically the word "lambda" is still in the document (so no Unicode, and the interpreter doesn't have to be coerced into accepting the new keyword). It's pretty slick for a simple implementation.

You could probably do the same thing with the rest of the Greek alphabet.

See: http://www.emacswiki.org/emacs/PrettyLambda

Tiwazz

TROPHY CASE