woot! 50K

Congrats!

thanks! =)

@ticker "I'm running a compiler" ...yeah

thought it'd be same guy who was re-writing Windows in VBA

lol no, just a confused newbie :)

yeah i can see why he'd make that mistake considering the error messages.

> Learning two or more major skills like TDD, design, and unit testing at the same time can create a big wall that makes things harder and more cumbersome to learn. By learning each skill separately, you make sure you’re good at each of them.

That would have helped reading 2 years ago.

yeah I would agree. You can't cram all that concepts (and they are big each) in a day.

past-Iven tried to learn them all at once. Made minimal progress.

Then he started taking them individually and progress was fast.

it's also that each requires higher and higher level of abstraction but you can't get up there without having gone through the intermediate, too.

kind like trying to learn calculus without having had learnt algebra

I would argue that there is a natural progression from design to unit testing to TDD. I don't see how one can start at say, TDD without knowing design or unit testing first. By the same token. One might be able to start with unit testing without knowing design, however.

I have a funny story about algebra

see I started programming around age 12, before school introduced me to any such funky math

and I just could. not. pick. it. up.

dunno why

it eventually "clicked" though

then I faceplanted calculus and gave up on school, but that's another story

Have another try at calculus. With this thing called the interwebs you could learn it pretty solidly.

Strictly speaking, programming doesn't require math. It requires logic. It just happens that both math and programming requires logic.

3 semesters in high school, 1 in college. All the same calculus book. 4 straight Cs. I decided that Actuarial Science wasn't in my future...

Calculus taught from a scholastic perspective is dry at best.

when you think about it, it's kind o funny - school never teach logic as a subject

and if they do, it's usually at post secondary level

yet it's much more foundational

^

IMO it would fix a lot of what students struggle with way sooner.

@IvenBach oh, I had 2 other tries :)

I've also suspected that the way math is taught is very badly. They're basically "look, mumbles mumbles equals zero. It works out!"

The best math teacher I had was when we were doing geometry. He made us do the rigorous proof. That was a godsend.

some did not like it very much but when he insisted that we prove that a triangle was congruent to another, it really forces the logic to foremost.

these days, they've come up with 427 new ways of teaching math. Many of them are really good, but only for the kids who don't grasp it the "standard" way. unfortunately 90% get the "standard" way, but they don't seem to teach that any more so they all have to struggle. Equality

Once you know how to prove something, then it becomes easier to follow what they are asserting to you in other math subjects... I think.

@FreeMan see, I dispute that. There is only one way of doing math.

Yes, you can cut corners and take shortcuts and skip some obvious steps but in the end it's all the same.

But there are many was of teaching how to do that one way. Some kids people grasp one way others grasp a different way. All this common core crap is taking one (or 50) of the alternate ways and forcing everyone to learn it that way. The normal way of teaching it has been working for decades/centuries. So many kids are struggling with math now and their parents can't begin to help them because these new ways of teaching are baffling.

It's great to use an alternate method or 20 when you've got a couple of kids who aren't grasping the concept - they'll usually get it from a different angle. But they're forcing the alternate ways on everyone and it's a pure waste of time.

Wife taught for 20 years (not math). Current US laws on not only what but how to teach are a great reason for me to mount my soap box!

and that is where I question whether this is a problem of not teaching enough logic.

well, yeah, there's a lot of that not going on.

I don't know about y'all but it always seemed that they always go in a variant of "you can do this way!" but never "this must be so because...."

@FreeMan that's part of why I'm happy to still be at work when the kids come back from school and need help with their homework

I would sooooo mix them up with my old decrepit ways from the '90s

oh nice

> Thanks for the in-depth explanation! I do use Rubberduck quite a bit, without it my 6k-line VBA program wouldn't be manageable.

I would like to add that calculus is rather far away from what math really is.

Math is essentially about logical thinking, not making implicit assumptions and simplification by abstraction.

Hmm. Are you saying that calculus won't give precise enough results? The way I remember it, calculus works because we basically approach a limit where it becomes small enough to actually match the shape (e.g. calculating an area bound by a line on graph).

No, what I am saying is that calculus usually is just about how to compute some area, integral, derivative or such.

There usually is also a real math version of calculus, in which you start by defining real numbers and prove a lot of things about functions starting from there.

Ah yes. there is a distinction between applied calculus and .... just calculus? At least that's waht they called them in my college years.

I took the former, not the latter. I do not really have any formal math (e.g. the theory type).

Things like that if you have a continuously differentiable function, take the difference in value for two different points and divide by their distance, there must be a point in bewteen those two points at which the derivative equals the calculated value.

As a professor at my university once told, this is the basis for the speed control method used in the Netherlands.

Anyway, I am just making the distinction between applied calculus and math because a lot of people do not know that math is a totally different beast than they think.

Before you have a class on it at the university, you have no idea.

Even quite a lot of math students do not get the difference in the first semesters.

They still think that it is about learning the techniques to calculate different things and the results of theorems, while it is actually about the way of thinking involved in proving the theorems.

Right - I see what you mean. I did not realize until much later on that the theoreical math was more about proofs and making a statement. It was my last math class when I had a taste of what they really mean about proof and taking nothing for granted.

Btw, that kind of thinking is why good mathematicians are usually not the worst programmers.

to oversimplify - nobody is taught to question why 2 + 2 must be 4 until much later on.

^

Agreed. That's why people usually think programmers have to be a good at math, too but that is not always the case, as Mat showed .

Actually, depending on where you look, it might be 0 or 1.

good programmers are probably good at math, as @M.Doerner showed ;-)

Well, you learn to juggle a lot of facts in your head at once.

That helps when dealing with things like the resolver.

And you are used to find patterns.

Juggling involves lot of math, especially when you get to 5 and 7 balls.

@MathieuGuindon Interestingly enough, being good at math doesn't necessarily translate to being a good programmer, though.

about the resolver - I think my biggest roadbump is understanding the terminology. "binding" leaves me perplex, for example.

Bjarne Stroustrup said in his book that of the people he worked with, mathematicians were consistently the worst programmers.

Still, people good at math not making an effort to educate themselves on proper programming techniques can write the most horrible spaghetti possible.

I wouldn't be surprised if it is because programming isn't as strict--it's much harder to make a proof that code is correct in C.

Or that even if it is correct, that unexpected errors are handled safely.

They'd probably be a lot better off working with something like F*.

At least pure mathematicians are usually rather good at abstracting things. PAired with the single responsibility principle, that can work out rather well.

@23fc9a62-56de-47fb-97b4-737890 worse than BASIC programmers?

@MathieuGuindon A binding is just some class that knows how to reolve a special kind of (sub)expression based on the its subexpressions.

it's bindings all the way down :)

@MathieuGuindon Probably not.

This was back before business people were able to blunder their way around that easily.

C/C++ aren't easy.

It ends in bindings like LiteralBinding of SimpleNameDefaultBinding.

Those know how to find the declaration.

Argh, why do I keep missing the s when typing resolve?

I just blame the coffee I spilled on my keyboard when that happens :)

@M.Doerner for me, the hardest part is keeping track of who is calling whom and why

I will write a short article in the wiki some time soon.

However, it is actually not too complicated.

#EasyIsRelative

It is just a bit hard to see when shtly looking at the code.

I suspected it would be some kind of decision tree but without a graph, it gets lost in the forest. I really wished there was a way for GitHub to generate a graph of the objects. I think Comintern mentioned CodeLen but I never got it to work. I wouldn't bother with statically graphing since code will always change and graph will be just like comments -- misleading.

The IdentiferReferenceListener calls the various overloads of Resolve on the IdentifierReferenceResolver.

Those take the statements apart and use ResolveDefault to deal with all kinds of expressions.

@M.Doerner ha! that hasn't changed since my bob-the-painter silly dumb implementation!

@this thing is, the "graph" is really the grammar - quite hard to chart out

(right?)

That method does two things: first is uses the BindingService to get a tree of IBoundExpression objects representing the resolved expression and passes it to the BoundExpressionVisitor that generates all the identifier references.

The graph is a bit different from the grammar as it incorporates contextual information.

I thought grammar was basically the input but the declarations we get out is the output, so I thought of it as more of transforming from one tree (the grammar) to another tree (the declarations & references).

The BindingService uses IBindingContexts to reolve the expressions, mostly the DefaultBindingContext.

ok so what's a binding context?

The grammar iis the pasis for the parse trees.

yeah

The DefaultBindingContext transforms the subtrees representing expressions into a tree of IExpressionBindings.

Those know how to resolve their particular context based on the reult of the sub bindings.

so that would be used for anything involving any expression?

After building the tree, the DefaultBindingContext simply calls Resolve on the top-level binding and returns the reuslt.

That causes a cascading reolution of the entire tree, which yields a tree of reolved expressions.

Yes, we send all expressions that way.

Well, nearly all.

I see - then there's TypeBindingContext to resolve types rather than identifier references, and ProcedurePointerBindingContext, to resolve, uh, AddressOf {not-quite-an-expression}

Right

There is also a special resolution path for events.

doesn't that make DefaultBindingContext responsible for a lot of thing?

It basically resolves all expressions. However, it does care little where they come from.

And it is only responsible for constructing the binding tree.

I see

The actual reolution happens in the bindings.

Well, it actually knows hlaf of how arguments are resolved.

However, that is a bit annoying to all get into the bindings.

In some previous PR, I have replaced the confusing dynamic calls with the switch statements.

That should make it a bit clearer what is going on.

Nice. I'm glad we finally got rid of dynamics

yeah. probably boosted perf, too

^

Btw, I wondered whether we could speed up the resolver by switching on the RuleIndex instead.

It is the internal index used by Antlr to distinguish rules.

that's pattern-matching going on here, I'd assume that's heavily optimized at the compiler level?

I hope so.

I suppose switching on an int must still be faster though, yeah

but less expressive :)

We then only need to cast for the matched rule.

Anyway, that was just a thought.

I will rather make the reolver slower with my current PR by doing more stuff.

that "stuff" is yet another game-changer though. we're getting closer and closer to understanding VBA code just as well as the VBE. soon we'll surpass it :)

Since my PR also introduces separate references for all default members in a recursive default member reolution, we should also be able to do the not host/control-specific part of the MakeDefaultMemberCallsExplicitQuickFix.

ttqw

@M.Doerner I don't think it needs to be host-specific -- all information we need is already contained in the typelibs so we should be able to resolve it from that without needing to knowing beyond identifying the document's class.

Hm, another bug in the resolver.

Call New Class1 should blow up, even if Class1 has a default meber.

Hm OK, that is not legal according to the spec. However, alowing it would be consistent.

specs are one thing, ...does it actually blow up in the VBE? (invalid use of property?)

magic numbers are the best numbers gives me the sads.

fwiw, any divergences we find from the specs should be commented

we already found a few, IINM.

maybe one day we can go to MSFT, show them our specs and have them use it. >:D

We found all your inconsistencies in 30+ year old coding.

^

Bring it to Joel and Bill both. "Hey guys you overlooked a few of these."

[rubberduck-vba/Rubberduck] rubberduck203 created comment on pull request #4681: Introduce mocking framework

> This PR is so far beyond the wildest dreams I ever had back when Mat and I were implementing the very first unit testing frameworks that preceded Rubberduck becoming a project, I’m completely speechless. Amazing work.