raminasi posted:

The Art Of Unit Testing is really, really good

MononcQc posted:

Can you define what you mean by "wrong rate", like basically the VAT should be denormalized and stored at the time of the invoice rather than mutating with the current rate the entire way through?

MononcQc posted:

<stuff>
Anyway that would be the simple way to go without caring too much about whether it's clean or not.

quote:

But yeah, having mostly finished writing a testing book, a big problem is that interesting tests require interesting codebases to demonstrate stuff, and having to introduce an interesting system just to test it after the fact is a hell of a lot of work (both for reader and author), and it's hard to make it interesting to the reader. You've got to dump a bunch of code going "this is not actually relevant to the lesson in this chapter but you have to go through it anyway, sorry!"

MALE SHOEGAZE posted:

no such thing

tinaun posted:

with enough syntax you can make Result based error handling look like exceptions

Spime Wrangler posted:

my understanding is that is literally what happened

the dude was apparently some wild-haired physics phd greybeard, and who knows what the thing was or did or why he was able to command those prices

redleader posted:

low level langs are great for all the pearl-clutching about "ownership" they bring out. just let your gc take care of memory, and let finalizers take care of any other resources. ez and objectively, inarguably correct

Shaggar posted:

powershell is c# hosed up by pseudo-linux script syntax.

It should have been csharp script from the start.

mystes posted:

Finding the total size of the most recent 5 files in powershell and turtle (admittedly I suck at haskell so the haskell version is probably not the best solution).

quote:

dir | Sort-Object -Descending -Property LastWriteTime | select -first 5| Measure-Object -Property length -sum | select -expand sum

quote:

> open System.IO;;

> "C:/myButt/" |> Directory.GetFiles |> Seq.map FileInfo |> Seq.sortByDescending (fun fi -> fi.LastWriteTime) |> Seq.take 5 |> Seq.sumBy (fun fi -> fi.Length);;

quote:

> using System.IO;
> using System.Linq;

> Directory.GetFiles("C:/myButt").Select(f => new FileInfo(f)).OrderByDescending(fi => fi.LastWriteTime).Take(5).Select(fi => fi.Length).Sum()

mystes posted:

Oh another haskell thing: there's a new "Simple GHC (Haskell) Integration" plugin for vscode that has no dependencies (it just uses ghc). It's a little bit buggy but I can at least get it to work mostly which is more than I can say about the older pugins that use intero, etc.

mystes posted:

I think you also need to have the haskell syntax highlighting plugin installed even though it isn't included as a dependency.

By default it autodetects whether you're using stack based on the presence of package.yaml and you shouldn't need the ghc executable to be located in a folder in your path in that case (it will run it via stack). However, it doesn't seem to show any errors if it has trouble running ghc for some reason.

It seems to be alpha quality but I still prefer it to the alternatives.

quote:

-> :set prompt ""
ghci | HelloWorld-0.0.0: initial-build-steps (lib + exe)
ghci | The following GHC options are incompatible with GHCi and have not been passed to it: -O2 -threaded
ghci | Configuring GHCi with the following packages: HelloWorld
ghci |
ghci | Warning: Didn't find expected autogen file:
ghci | D:\myPath\HelloWorld\.stack-work\dist\7d103d30\build\HelloWorld-test\autogen\cabal_macros.h
ghci | GHCi, version 8.4.3: http://www.haskell.org/ghc/ :? for help
ghci | <command line>: cannot satisfy -package hspec-2.5.5
ghci | (use -v for more information)

mystes posted:

I don't understand the haskell tooling well enough to say why this is happening, but it looks like you can fix this by forcing stack to get some additional dependencies:

code:

stack build hspec
stack build yesod-test

These are presumably dependencies of the project and not the plugin, so I don't understand why these are needed when the plugin tries to run ghci but not for stack build; are these associated with different targets than the executable or something? (I assume that this may partly be a bug with the plugin in that it doesn't run stack ghci with the proper command to pull in the packages for some reason?)

HoboMan posted:

my code as it stands

"Sent email" will get logged, but if i hard code an exception in the try block "Exception sending email" will not get logged.

e: i literally just added the using and Task.Run blocks around the existing try-catch that was there.

e2: i forgot to include the try-catch for the json parsing, but you get the idea

prisoner of waffles posted:

attributes are guaranteed to have 0 or 1 cardinality and their order is insignificant tho

Kevin Mitnick P.E. posted:

realistically, as someone who consumes XML, there are three cases

1. there is no schema
2. there is a schema but it is wrong
3. the xml is generated by serialization and the schema is redundant

the correct approach in all three cases is "read it into a tree and grab what you need with xpath"

Doom Mathematic posted:

The problem is that just because a problem is objectively caused by someone else, doesn't mean that you're not the one who has to "fix" it.

white sauce posted:

In java, what does this statement mean when you're creating a class?

cinci zoo sniper posted:

i do recommend options other than postgre only to people who don’t need rdbms recommendations

animist posted:

google cache invalidation. you'll thank me later

floatman posted:

Powerful Two-Hander posted:

that would leave open the case of "job got set to processing and never finished because it halted half way" though which yeah i guess you could solve via a time out or whatever or through a db transaction or something buutttt why not just have you queue read by a single process dispatcher that passes the jobs to workers that do the actual thing and write success when they're done using the job id directly ?

any time the dispatcher fails it'd just start up and pick up the next x jobs and carry on and you don't have to worry about messing with db locking at all and the workers don't need to know or care about the priority.

Shaggar posted:

read uncommitted (aka nolock) wont work for that since multiple processes performing the same query will get the same dirty data and then all attempt to pull the same row for processing. you need to use readpast and updlock which will read past locked rows and then lock only your row you intend to process.

cinci zoo sniper posted:

eh, for testing maybe, for production im not a fan db.t2.xlarge or db.t2.2xlarge because they are postgresql 9.x. for you 10 is more or less needed, 11 is desired (which is only on rds preview right now i think) if you want to do partitions, rather than brin indexing.

Shaggar posted:

wouldn't this cause a race condition wrt the update? like if 2 processes have selected the same job id and then theres a delay between when one attempts to update and its selection of job id, you run the risk of the faster process successfully updating and committing before the later tries its update. so when the second does its update the first process's lock will be gone so the update will work.

Shaggar posted:

same. also they can then standardize on a .net runtime and every browser will ship with it and eventually javascript can be abandoned

CRIP EATIN BREAD posted:

also make an AI that sends groups of enemies in a formation spelling out "YOSPOS", tia

Finster Dexter posted:

saunas are supposed to be really good for you, too

I might be tempted to work a few extra hours if the boss has a sauna put in at the office

gonadic io posted:

Can you use a docker container as a host for its own set of containers? One of the requirements is to be able to have a function of type Docker<Docker<Butt>> to Docker<Butt>

hackbunny posted:

a good deal of voip calls are routed through a 30000+ line C source file

https://www.typescriptlang.org/docs/handbook/advanced-types.html posted:

Mapped types

A common task is to take an existing type and make each of its properties optional:

code:

interface PersonPartial {
    name?: string;
    age?: number;
}

Or we might want a readonly version:

code:

interface PersonReadonly {
    readonly name: string;
    readonly age: number;
}

This happens often enough in Javascript that TypeScript provides a way to create new types based on old types — mapped types. In a mapped type, the new type transforms each property in the old type in the same way. For example, you can make all properties of a type readonly or optional. Here are a couple of examples:

code:

type Readonly<T> = {
    readonly [P in keyof T]: T[P];
}
type Partial<T> = {
    [P in keyof T]?: T[P];
}

And to use it:

code:

type PersonPartial = Partial<Person>;
type ReadonlyPerson = Readonly<Person>;

DELETE CASCADE posted:

why does javascript, an interpreted language whose linkage model is "everything in one global scope as though it were a single file", have a build system

CRIP EATIN BREAD posted:

that's basically what npm does, since it's copying a dependency to every project. and those dependencies can change between runs of "npm install" because the entire js ecosystem is a broke mess.

it's a poo poo system.