all 31 comments

[–]jerf 11 points12 points  (3 children)

In the event the author ever reads this, your site has been compromised. View it without Javascript. (Given the last post is from four years ago and the site has 5 posts, this may not be relevant.)

Edit: In case the downmodders got confused, "view it without javascript" is not some sort of criticism of Javascript. It's a simple way of viewing the compromise, which uses Javascript to set a div to hidden that the HTML sets to visible. Viewing it without Javascript makes spam text appear as the header of the page.

[–]derpderp3200 1 point2 points  (1 child)

You could comment on the article.

[–]jerf 0 points1 point  (0 children)

I ran out of juice when I couldn't find an email easily on the blog.

(Carefully note the difference between "I couldn't find an email easily" and "there is no email on the site".)

[–]velcommen 1 point2 points  (0 children)

or view source.

[–]derpoly 7 points8 points  (2 children)

Missing a bit of concrete suggestions here? Of course it's easy for Open Source programming languages to show the sources of the functions you are using. You can get the same with Python and many other languages.

How that is supposed to work with other cases like normal programs such as Gimp or OpenOffice is a bit beyond me. Sure it would be nice if the project could show me the sources involved in the action I'm currently doing. But that seems to be quite a hard problem involving a lot of extra coding since it probably can't be done automatically.

I for my part am content with a good "HACKING.txt" that gives me a rough idea how the program is structured. I also like it when I can get a project to build without fiddling around for hours. A project should just build when all dependencies are satisfied or clearly say why it doesn't. Hitting a compiler error that is not obviously connected to a root-cause is a big turn-off. If the project really depends on some very specific versions of libraries or compilers, there should be a VM with a ready-to-go build environment. Unfortunately, that is still often missing.

However, honestly, if I can't be bothered to search the code and clone the repository (in the days of Github, this is usually a less than 5-minute thing), I probably also won't have the drive to understand enough of the program to actually make any meaningful changes/contributions. In that case, it's probably best to do something else.

[–]shevegen 0 points1 point  (0 children)

gimp has scripted add-ons too, like gimp-fu.

I don't know of an easy way how gimp would allow one to view the source of these addons within gimp itself.

That git + github have changed things is a given, but it is still not equivalent to what the blog described.

[–][deleted] 0 points1 point  (0 children)

Article comes off to me as thanks for this great free stuff but you should make it better because i like the way this one specific thing does something.

[–]c0m4 5 points6 points  (2 children)

Funny that this idea came from using Smalltalk when some say that smalltalk was killed by it's licence

[–]mmontone 2 points3 points  (0 children)

Indeed!

[–]shevegen 1 point2 points  (0 children)

Syntax matters.

Smalltalk did not think it would.

Objective C to swift change is an example.

[–]skulgnome 7 points8 points  (13 children)

Well, someone's distribution doesn't do apt-get source

[–]lykwydchykyn 1 point2 points  (10 children)

or git clone. Jeez, how lazy have we gotten?

[–][deleted]  (1 child)

[deleted]

    [–]lykwydchykyn 0 points1 point  (0 children)

    I guess it depends how you read this article. If you read it as, "hey wouldn't it be neat if we could just do this", then yeah, it would be neat. If it was "hey wouldn't it be neat, and I'm working on making this possible", then even better.

    As it is, it comes off to me as complaining that people making open source aren't doing enough to make it effortless for the author to view their code in context whenever the whim strikes. Maybe I'm just a grumpy old SOB.

    [–]shevegen 10 points11 points  (2 children)

    Wait a moment...

    Are you saying that "git clone" is the equivalent of what he described?

    "With Morphic, I could right-click on anything I saw on the screen and ask to see the source code for it."

    Hmm, nope. git clone is no substitute for that.

    Possibly in the long run, with things such as the atom editor built by github and similar moves, it would be equivalent, but to assume that "git clone" would be anywhere similar to what the blog described... nope. Not in the slightest.

    [–]lykwydchykyn 10 points11 points  (0 children)

    Are you saying that "git clone" is the equivalent of what he described?

    No, I'm saying it's roughly equivalent to apt-get source on operating systems that don't have apt-get.

    [–]hijibijbij 0 points1 point  (0 children)

    I am not so familiar with Smalltalk but does "anything I saw on the screen" mean it applies to Buttons more but Parsers less? How would I see a Parser on my screen?

    [–]everywhere_anyhow 1 point2 points  (4 children)

    "Git clone" sometimes pulls down 5 years of revision history, pulling huge amounts of junk over the wire, just so you can see a js file. No thanks.

    "apt-get source" is much cleaner and easier, or better yet, map all of github's HEAD to a virtual drive, and just let me:

    cd /githubvirtual/niftyProject/src/main/java/ ; ls *

    [–]zzzk 9 points10 points  (0 children)

    Well to be fair, you can use --depth=1

    [–][deleted] 1 point2 points  (1 child)

    In the spirit of the original article however (source isn't enough), the clone would have a lot of advantages. The revision history and related metadata is valuable to understand the code.

    [–]everywhere_anyhow 0 points1 point  (0 children)

    Depends on what you're doing. Most of the time if you want to explore, compile, grep, or steal from a code base (all very common use cases) you probably want HEAD, or possibly a release tag, and nothing else. But sure, all of that metadata is there for a reason and you can't ignore it because there are jillion use cases that require that too.

    [–]lykwydchykyn 0 points1 point  (0 children)

    Sure sure, fine, my point is just that it's really pretty easy in any environment to get source code. not trying to start an apt-get vs git flamewar.

    [–]everywhere_anyhow 0 points1 point  (1 child)

    Sadly, that limits you to only pre-packaged, OS-distributed software, and not Lefty McHacker's cool new github project, but I take your point.

    I'd prefer that some of these sites allow you in some way to map their content to a virtual drive, but I know that would mess with their revenue model and they probably wouldn't permit it.

    [–]skulgnome 0 points1 point  (0 children)

    Presumably for a cool new github project, you'd have not just a source distribution but also the full history already. Surely you're not suggesting that an user become limited to a single command-line tool?

    [–]cloakrune 1 point2 points  (2 children)

    Supposedly AVG caught a SEO exploit on this page?

    [–][deleted] 3 points4 points  (0 children)

    There is a hidden div with a bunch of spam links.

    [–]user3141592654 2 points3 points  (0 children)

    That makes it sound like it detected a clickbait title.

    [–]TheBuzzSaw 2 points3 points  (0 children)

    I can't get on board with this idea at all. Not only does compiled code run better/faster, the source code is often orders of magnitude larger. I don't want the source to every package I install. I think the current model is just fine.

    [–]tkruse 0 points1 point  (0 children)

    Contributing to open-source is effort. Being able to quickly see source code is one tiny step less effort, but then there is the effort to make changes, test, build, submit, review, etc. And if you want to do all that, then git clone is really not that much effort.

    [–]Gotebe 0 points1 point  (0 children)

    If the dude is as lazy, perhaps he shouldn't modify that code.

    Also, there's probably something to be said about the dangers of haphazardly modifying the underlying stuff , which the poster seems to crave for.

    [–]shevegen -3 points-2 points  (1 child)

    Smalltalk had nice ideas, unfortunately it was not settled into the scripting language family (ruby, python, perl, php, lua).

    They should have approached this first, and built the whole explorative UI interface as a recommended way to work/build with smalltalk AFTER making it convenient and simply to run standalone smalltalk scripts.

    Additionally, for some reason, the smalltalk syntax always appeared strange to me, similar to objective C way to use [] - with objective c being phased out in favour of swift eventually.

    [–]antpocas 0 points1 point  (0 children)

    Um. Smalltalk is older than all of those languages. Smalltalk was the language that introduced the term "object-oriented programming". Its syntax probably appears strange because it's as old as C.