« first day (1460 days earlier)   
00:00 - 19:0019:00 - 22:00

7:00 PM
@enderland I did. :-)
@MichaelT That's crazily over the top
Used way too many coats for the poly finish.
@GlenH7 the really funny thing is how much he went through to hand out a $20 bottle of whiskey
at that much work, he could have at least gone with Jack Single Barrel
@JimmyHoffa Yeah, definitely could have upped his game there too
Gentalman's is good sure, but... not good enough to warrant that kind of effort
oh weird unexpected mod perk, I can delete my messages older than 2 minutes?
@enderland yep. And edit them too.
7:10 PM
@enderland you can delete or edit my messages older than 2 minutes too - also you can purge edit history of a chat message - so I wouldn't be able to view history on your (removed) above
@JimmyHoffa Oh cool let me try this! delete * from chat where userid=22076
@JimmyHoffa but only before removing it, otherwise the last value is always there
@enderland Shouldn't that be '%monad%'?
We're collecting blue names again...
7:12 PM
to completely hid a message requires changing it to something else, then purging history
@enderland there's a button for that
Yeah I never even noticed that until just recently
@MichaelT that's pretty awesome
@enderland We expect you to pick a superior drink if you go down that route... :-)
Neither of us drink though, bwahahahaha. though my brothers would love to get one of those
7:20 PM
So show 'em some love....
@MichaelT I'mma lady and I still would like that :P
A groom's cake is a wedding tradition originating in Victorian England, but observed more often in the modern age in the American South. While a wedding cake may often be decorated in white and light in texture or color, the groom's cake can take a variety of forms, many incorporating chocolate or fruit. Cheesecake sometimes serves as a groom's cake. The groom's cake is often served at a table separate from the wedding cake at a wedding reception or wedding breakfast, though it may be served as a dessert for a rehearsal dinner. == History == Originally, the groom's cake was a British tradition...
> One tradition was to cut a piece of the cake and put it in a small box, then present the box to an unmarried woman attending the wedding. The woman was not expected to eat the cake, but rather to put it under her pillow. Superstition held that this tradition would help an unmarried woman find a husband.
@MichaelT What a waste of cake!
Some may consider the lack of cake to be a good trade off for finding a husband.
@MichaelT Whereas some may prefer to just have the cake.
7:24 PM
> Originally, the groom's cake was a British tradition. The groom's cake was often richer than the bride's, since the addition of flavors like chocolate, fruit, and especially alcohol were better served to "the stronger sex" with the stronger stomach. During the Victorian era, the first groom’s cakes were heavy and dense fruit cakes. A characteristic recipe for the groom's fruit cake was published in the “The British Baker" in 1897.
Hmm... were are those cupcakes?
I still need to make them
I just keep forgetting to get the alcohol I need :P
@MichaelT I kinda want to try that technique for making the box with something
not sure if it'd be used for that but maybe christmas gifts or something?
I'm off 60% of october
@AshleyNunn That could be the tag line for this room...
7:31 PM
@GlenH7 Very true :)
@AshleyNunn looking forward to being able to get some for my wife in a few days
baby almost ready to come out
@AJHenderson Oh nice. :)
Sweet :D
My take on strong/weak language features.
@MichaelT how about throwing performance in there? ;)
7:35 PM
I had a friend who had a baby three months ago and about a month after she had him she was like "I need someone to go alcohol shopping with me" because her husband doesn't drink and stuff so I was like PICK MEEEE. It was a fun adventure
and actually, most recent version of C# can do quite a lot of implicit type stuff with dynamics, so that's a bit dated
@MichaelT Wait, how does C score lower than Java in pointers?
@Ampt pointers allow you to subvert the type system.
Thus, having pointers is a weak type language feature.
void * FTW!!!
int main(void) {
	float f = 0.1;
	int i = *(int*)&f;
	return 0;
I can also do some rather nasty stuff with Perl's scalar (which is a union) that confuses people.
Thus, it scores lowish on the untagged union metric too.
But, the thing that I'm trying to point out there is that weak/strong isn't one thing.
Though its still flawed at some level:
For example, someone who believes that a type system is "strong" if type errors are impossible at runtime would characterize C# as "weakly" typed, because C# allows the developer to insert type conversions that will fail at runtime. (example: short x = (short)(object)(123.ToString());) Someone who believes that a type system is "strong" if it encourages writing programs where the compiler finds many but not all type errors at compile time would characterize C# as strongly typed for the same reason. If the same feature of the type system can be reasonably characterized as both "strong" and
7:46 PM
@MichaelT Of course Lippert beat us both to the punch, saying exactly - as always - what needed to be said, in this case that "strong typing" is a made up term with numerous definitions none of which agreed upon and basically a term that lacks specificity necessary when talking about type systems
Granted people know so little about type system... there should be an undergrad class on them or something
it's very helpful to understand type systems - that classifies as one of those post-grad things that you genuinely do use in industry
Survey of Type Systems would be a good class to have... not so much 'we're interested in the language padigrims' but just the type system offered.
@JimmyHoffa typing is covered in some undergrad programs
not as it's own course though I suppose
but in reasonable depth
In my classes, the type system was glossed over in the compilers (it was just something you had)... and it was also only touched on in Theory of Programing Languages which were more about OO / Procedural / Functional / Declarative concepts.
@MichaelT exactly. Knowing multiple paradigms is useful, but knowing the underlying decisions and tradeoffs made for at least the type system you're living in is almost necessary if you want to make the best decisions you can in your language
@MichaelT we wrote our own compiler
7:51 PM
@AJHenderson so what's "strong typing" ?
@AJHenderson 536... Prof. Fischer taught it when I took it.
@MichaelT it's unbelievably weird that you still remember teachers and their names. I have been out of school a lot less time than you and frankly remember bupkis mostly
Charles N. Fischer

Crafting a Compiler is a practical yet thorough treatment of compiler construction. It is ideal for undergraduate courses in Compilers or for software engineers, systems analysts, and software architects.   Crafting a Compiler is an undergraduate-level text that presents a practical approach to compiler construction with thorough coverage of the material and examples that clearly illustrate the concepts in the book. Unlike other texts on the market, Fischer/Cytron/LeBlanc uses object-oriented design patterns and incorporates an algorithmic exposition with modern software practices. The text and its package of accompanying resources allow any instructor to teach a thorough and compelling course in compiler construction in a single semester. It is an ideal reference and tutorial for students, software engineers, systems analysts, and software architects.
@JimmyHoffa there were a number of good professors who were ones that you learned from... he also looked like a hyperactive chipmunk in his younger days.
@JimmyHoffa I still remember a few; it's the ones that made a really strong impression.
@JimmyHoffa personally, I would classify it as a language where type is strongly associated with the data structure such that you can detect invalid operations (but that may allow that to be overridden anyway), but I also realize that isn't the only definition people might argue for
I'd classify C# as strongly typed
even though it allows you to break from that if you want to
7:54 PM
@AJHenderson thing is the term just has no real definition, it's thrown about a lot but is totally ambiguous. People use it as a blanket term referring to one of numerous features of a type system, but without agreement on which feature means the term can't be used to effectively communicate anything concrete
strong typing is like a coke in the south
@JimmyHoffa yeah, I know, it's more of a spectrum
woot I think I implemented AMDs "correctly" :D
need to walk the spec some more to test myself
actually I think there are test scripts out there...
8:18 PM
@MichaelT Amazon customers don't seem to like this book very much.
It made a lot more sense in combination with the undergraduate class.
Without that context, it can be a difficult read... Dragon book is probably better if you don't have the class background.
8:45 PM
@MichaelT that seems to be the case with a lot of text books written by the professor teaching the class
Yeah, the teacher can be there to rescue those concepts described inadequately in the book.
well not just that, but they tend to think of it in terms of filling in the gaps they aren't covering in class
I've certainly seen some where the book is very clearly written to correspond with the class
very specifically
.NET Fact Of The Day: The most common time for GC to collect is on allocation. If you have any bit of code you know does lots of heap allocations for whatever reason, keep in mind GC may be collecting frequently there as collection is often the first thing that kicks off as soon as the CLR decides it's within one of it's tolerance-ranges for heap available to the process
Microsoft has already done the leg work for you. Why not simply adopt their standards? Every development team should have a coding standard. Everyone on the team should follow it, and it should be enforced by a code formatter or some sort of linting program. There are many reasons why this is a good thing; consistency is the most important one. Not being regarded as amateurs is another. — Robert Harvey 4 mins ago
Too harsh?
@RobertHarvey That's harsh?!?
8:55 PM
Well, the amateurs thing.
@AJHenderson using blocks are so far removed from having any relation with GC... ok, well generally....
@RobertHarvey pfffft
Sometimes a little ego poke can go a long way. Most of the time, not so much.
@AJHenderson if you believe using adds determinism to GC - disavow yourself of that truth right now because it's commonly believed, and 100% wrong.
@JimmyHoffa they ensure destructors are called to make sure that things are disposed, I suppose they could hang out until the GC next goes, but you could trigger it if you wanted then
8:57 PM
@AJHenderson finalizers - not destructors (destructors have deterministic behaviour, finalizers do not)
All using does is call Dispose() when you leave the using block.
Has nothing to do with garbage collection.
and finalize is unrelated
and a using only disposes as well as the IDisposable's Dispose method per the implementor of that given class. If it doesn't GC.SuppressFinalize and it has a finalizer, the object stays pinned and the using had no effect on your GC behaviour
that GC.SuppressFinalize call is the entirety of how a using effects GC, and it's not always there (usually not necessary as only the lowest layer unmanaged resource should implement a finalizer) - as such using usually has 0 effect on GC
in essence like the "try with resources" in java (which is a clone of the using block)
9:00 PM
Ah, well if you use using like this
using (Font font1 = new Font("Arial", 10.0f))
    byte charset = font1.GdiCharSet;
I'm pretty sure we have some things that do manual garbage collection periodically to grab anything that has been disposed, I know we've made a lot of specialized alterations for garbage collection in our framework, but I don't go poking around in that particular code often
The font1 variable gets scoped to the using block, so it gets deallocated when execution leaves the block.
@AJHenderson it's sugar that expands to:
I know when we weren't using using blocks, we had the GC think it couldn't touch things that it could and it would think they were small, so it wouldn't touch them, but really they had pointers to big things
//the line of code inside the using parens
  // the code in the using block
  (yourVariableFromTheUsing as IDisposable).Dispose()
9:02 PM
yeah, that I knew, I just forgot that dipose doesn't actually dispose without telling GC to collect explicitly
it just marks the thing as dead
@AJHenderson haha yes well... GC can't collect objects with a finalizer - unrelated to the using just remember - EVERYTIME YOU IMPLEMENT A FINALIZER YOUR CREATING AN OBJECT THAT CANNOT BE MOVED AROUND IN MEMORY
and actually, if I was thinking more clearly, I think that was floating around, I just have baby on the brain at this point
objects that can't be moved around play hell for your heap because they're like mile markers, the heap grows upwards and as you add immovable posts you stop it from shrinking bit by bit
@AJHenderson haha yeah, that'll ruin a lot of things
@JimmyHoffa now that one I don't think I knew
I knew the upsides of iDisposable but not that it prevented it from being moved. So that really makes it even more critical that once you implement it you need to make sure it is called even more than if it wasn't implemented (if I'm understanding you right)
no it's the finalizer tham makes it immovable
finalizer and IDisposable are orthogonal
9:06 PM
ok, what's the difference between the disposal and the finalizer, I should know this, but my memory is flaking
hmmmm so enderland's "find a dream job" saga continues! ha
is that the ~ thing
@AJHenderson yeah - finalizers are referenced from GC because the assumption is: You wrote a finalizer, so you have something that you absolutely cannot allow to leak - and no one is responsible for except you - so GC holds a reference to your finalizable object to execute the finalizer if it goes out of scope. Finalization is a last ditch effort of the GC to stop resources from leaking.
disposal is determenistic in the user code, while finalizer is purely for the GC
It won't move your object if it has a finalizer because then the reference to your object from the finalization queue would be invalidated
9:08 PM
oh right, that jogged my memory
When you GC.SuppressFinalize you are telling GC to remove the pin and reference from the finalization queue to your object, make it movable, and when GC comes around it can compact or collect the instance depending on whether it's a GC root or not
Based on my readings of finalizers, it seems like they're difficult to get right, and that you shouldn't rely on them as a mechanism for proper cleanup. That's why using and IDisposable exist; otherwise, you could simply write a finalizer for each of your classes that uses unmanaged resources, and dispense with using altogether.
@RobertHarvey except for the aforementioned issue of GC not accurately judging size
our specific problem was that SQL Connections and contexts associated with our units of work show up as small to the GC
but are in reality massive
or potentially massive
so GC ignores them
we have to dispose them to say "no, clean these up... really"
because it bumps up their priority
from what we've observed
it still isn't necessarily immediate, but it makes it go faster
Well, all the GC measures is the memory footprint. And technically SQL Connections are unmanaged resources.
and GC can't know what the unmanaged pointer is pointing to
9:13 PM
all I know for sure is before implementing disposable on them, resources leaked, after disposable and using blocks, memory clears up quicker, particularly from explicit collection calls
GC has nothing to do with that
Do you force a garbage collection?
the using blocks did
yeah, I think we forced a GC at some point, I last worked on that stuff like a year and a half ago though
so it's a bit sketchy in my head at this point
I'd have known it a lot better a year and a half ago though ;)
well, using tells GC that it can be collected, but I think we still needed an explicit call to make it collect everything since just marking it as disposed doesn't trigger a collection
no using makes the code call dispose on the object that cleans up the unmanaged
9:17 PM
oh, so the disposal cleans up the unmanaged, but then the disposed object (at a small size) can hang around
00:00 - 19:0019:00 - 22:00

« first day (1460 days earlier)