Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

The Wrong Kind of Paranoia

prog21.dadgum.com

Post reply on HN
Print view View original

31–40 of 54 posts

Re: The Wrong Kind of Paranoia

#31

Post by plorkyeran »

kstenerud wrote: post #8

Static also allows the compiler to make better optimizations, knowing that nothing outside of the current compilation unit will ever use it. Const also allows the compiler to optimize better with the knowledge that the called function won't perform any writes to the object state. Access modifiers give you a way to separate out functions that can be called externally vs those that shouldn't. The API doc generator won'…

In practice const very rarely allows any interesting compiler optimizations (passing a reference to a const local variable to a function whose body cannot be seen is pretty much the only place where it's safe to do so). The const overload of a function with const and non-const versions could in theory be faster, but copy-on-write data structures are the only common example of that actually being the case.

Re: The Wrong Kind of Paranoia

#32

Post by quanticle »

blt wrote: post #25

`private` is a joke in C++. Coupling happens at the header file level, not the class level. Any C++ programmer who cares about reducing dependencies should be thinking about header files, not classes. Man, we really need a module system. I think the problem is not that `private` exists, but that it is taught/sold to programmers as a silver bullet for making software architectures better. People think "Decoupled syste…

>Man, we really need a module system.

And you might be getting one: https://isocpp.org/files/papers/n4214.pdf

It's under consideration for C++17, as I recall.

EDIT: Also, CLANG allows you to use modules right now, but IIRC those are CLANG specific extensions and the final module spec. may or may not be compatible with them.

Re: The Wrong Kind of Paranoia

#33

Post by Sophistifunk »

Some of these things are simply to "nanny" us, but there's a very good reason for private / protected: The Namespace is a precious and limited resource. It's a good-thing(tm) not to pollute it with internal details, and what is unexposed need not be well-named, which is after all one of the 2 hard problems (along with cache invalidation and fencepost errors).

Re: The Wrong Kind of Paranoia

#34

Post by JoeAltmaier »

blt wrote: post #25

`private` is a joke in C++. Coupling happens at the header file level, not the class level. Any C++ programmer who cares about reducing dependencies should be thinking about header files, not classes. Man, we really need a module system. I think the problem is not that `private` exists, but that it is taught/sold to programmers as a silver bullet for making software architectures better. People think "Decoupled syste…

Perhaps 'private' is oversold. It can be used simply to isolate variable changes. So you don't have to grep the entire source for references. So you can make changes confidently. Yes there can be some leakage; but don't throw the baby out with the bath water.

Re: The Wrong Kind of Paranoia

#35

Post by Sophistifunk »

underbluewaters wrote: post #21

This post resonates with my experiences of the last 6 months. I'm a very good web developer, and have been working for a while now on a couple iOS projects. Coming from javascript which everyone seems to regard as dangerous and overall terrible, I expected that after some time I would get used to and appreciate working in Objective-C and Swift. Nothing could be further from the truth. While you can shoot yourself in…

I don't want to be "that guy" but it sounds like you're not writing Swift, you're writing Javascript in swift syntax. Optional as part of the type system instead of falling back on nulls and exceptions is IMO a very good thing. Try to embrace it with an open mind for a few years (yes, years) before declaring it a useless pain in your behind.

Re: The Wrong Kind of Paranoia

#36

Post by opinali »

I usually love James Hague's posts, but this one has his head buried deep in the sand. And he's enough of a veteran to remember early Lisp and Smalltalk systems, where excessive openness in all aspects looked awesome for prototyping/hacking or academic toy programs (or what is considered toy-size in the last 20 years anyway), but was a disaster even for the mid-1990's definition of programming in the large. Attempts to discipline these languages came too late, so they got overrun by competitors with lots of "paranoid" rules like C++, Java, hell even Eiffel. (Not the single reason of course but one important reason; not even the gurus could help themselves to not abuse dark magic and write application code that would be compatible across minor updates of the language/frameworks, let alone other compilers/VMs/platforms.) If you need extra evidence with more current technology, see most "bad parts" of Javascript (successful, but in the same way that the Titanic was wildly successful for one week; people who build large JS apps have been in a mad rush to fix or replace it for the best part of the last decade, hopefully with ES6 coming as a first major win in that direction).

TLDR sorry James, we have tried the elegance of extremely simple and open language/runtime architectures, and that was always an abject failure.

Re: The Wrong Kind of Paranoia

#37

Post by Sophistifunk »

mikestew wrote: post #15
plorkyeran wrote: post #6

> If they're not in the tutorial, examples, or reference, you don't even know they exist. If you use the header file for documentation, and internal methods are grouped together beneath the terse comment "internal methods," then why are you calling them? Autocomplete is a thing. Even if there is a big comment explicitly saying not to use a function, if it doesn't show up in the autocomplete window someone will inevit…

If I'm reading this correctly, you're saying that someone will use a function for which there is no documentation, no external reference, and the user hasn't even seen the code (since they didn't see the comment saying not to use it)? Just a function name and (maybe) a method signature in the autocomplete? The caller deserves whatever woes befall them.

Not only will they (attempt to) use them, but they will decry your half-assed documentation, and be right to do so.

Re: The Wrong Kind of Paranoia

#38

Post by simula67 »

I wonder how much the software state of the art is advanced by software developers as opposed to software maintainers.

When you are working to refactor software written by others, things like "private methods" are a gift. If you are trying to refactor some piece of code, you only have to make sure that the callers within the said class are modified to guarantee that the codebase is not broken.

I don't think a lot of people understand that maintainers in the real world do not have the time to read and understand every line of your code. And the toughest part of doing software maintenance is figuring out how much you can safely ignore. I feel qualifiers like "private" were designed to help with this problem.

I also severely dislike the architecture proposed by the author with loosely coupled services talking over a socket. This style of code is only maintainable if you understand the entire system inside and out. For example, lets say the maintainer receives a ticket that says 'Report X has wrong data'. She will start investigation with the question : 'Why does it have wrong data ?'. She will walk back up the call tree looking for why and eventually learn that the data coming off the socket is wrong and that is where the trail ends (unless there is a document describing who is responsible for putting said data there).

I have faced this issue in real life. I can understand when this style of decoupling is necessary to improve modularity, but it does not have a positive maintenance impact.

Re: The Wrong Kind of Paranoia

#39

Post by anabis »

I actually want _more_ possible restrictions such as limiting rage of values, or allowing only printable characters in a string.

As other comments say, its a documentation to future self and others.

Re: The Wrong Kind of Paranoia

#40

Post by buttchrist »

simula67 wrote: post #38

I wonder how much the software state of the art is advanced by software developers as opposed to software maintainers. When you are working to refactor software written by others, things like "private methods" are a gift. If you are trying to refactor some piece of code, you only have to make sure that the callers within the said class are modified to guarantee that the codebase is not broken. I don't think a lot of…

Apple have added a fantastic thing to iOS 8 and OS X 10.10 that I am terribly interested in but have managed to find nothing about beyond this post[1]. I think you'd be interested, it addresses exactly the problem you describe by including information from other threads and processes to crash logs.

[1] http://www.objc.io/issue-19/activity-tracing.html

Post reply on HN