tutorial for writing in code rather than using the GUI

BenM
Is there such a thing as a handbook or tutorial for writing in the code, rather than using the GUI?

XanMag
Why would you ever want to do such a thing?!? LOL

There are some pretty decent tutorials out there like codeacademy.com

Personally, unless you want to really learn code for the sake of learning code, browse the forums and ask questions on the forum for problems you run into while using the GUI. Not that my opinion on this carries much weight, but IF your intent is to write games using this Quest program I have found picking up some code tidbits here and there was incredibly more beneficial to my game writing experience than trying to learn code in order to write these kinds of games.

On the other hand, if you really want to learn a lot code, codeacademy.com does do a pretty good job of walking you through coding lessons. I just wasn't patient enough to get very far. HK uses it (as do I but I'm not dedicated enough) and it seems to have helped tremendously in his case, but HK has an interest in computer programming as an education, so...

As for there being a specific code handbook for Quest... no I don't think there is. Someone may correct me on that though. The 'How To' documentation may be worth having a look at if you haven't found that yet. http://docs.textadventures.co.uk/quest/guides/

That's the best I can offer. Good luck!

HegemonKhan
read HK's numerous posts, laughs :D

I have tons of posts going into great detail how to code in quest, much to the horror of new people who I try to help out... laughs.

either search through all of my posts (click on my account name, then choose to search my posts, and there's also my own thread when I first joined quest as a total code noob: HK's help me noob thread), or just use the site's search box and search for 'noob', 'new to quest', etc etc etc, as a lot of my good detailed code explaining posts are in those threads.

once, you have some understanding of quest's code, one of the best resources is the quest documentation itself:

http://docs.textadventures.co.uk/quest/

it has a ton of wealth in there (most commands and a lot of other useful stuff)

-----------

learning code:

1. learn the Attributes and their usage
2. learn the 'if' Script, and start training your brain in 'if~code~computer' logic.
3. with ability in Attributes and the 'if' Script, you can do 90% of everything that you want to do in your game (for example: you should already understand this fully at this point: http://docs.textadventures.co.uk/quest/ ... ation.html , as well as, at least basic, 'if' Scripting: be able to use 'if' scripting in your 'character creation' scripting to give different stat amounts depending on your choices such as 'race', 'class', or whatever)
4. next you can move onto learning List Attributes and then Dictionary Attributes.
5. look at (study) the guides, libraries, and code samples of the good coders here.

when~if you're ready you can take a look at my basic physical~weapon damage combat coding:

viewtopic.php?f=10&t=3348&start=120#p22483

and the key~legend for all of my abrevs... I've learned since to never use abrevs ever again... sorry about having to deal with them for this old code of mine:

viewtopic.php?f=10&t=3348&start=120#p22486

-------

when writing in code, there's two types of code:

1. the 'creation' tag blocks (your 'actual~existing physical things' in quest)
2. the scripting (your actions~events in quest)

also, note that code can be written horizontally (hackers can read this code; it's more efficient as there's less lines~less character~symbols~less file size) and~or vertically (easier for noob code people to use).

------

just like in real life and human languages, computer languages have a tri-structure as well:

1. matter(physics)~nouns(human languages)~Elements+Attributes(quest xml language): these have the 'creation' tags; your 'physical things' in quest
2. energy~forces~waves(physics)~verbs(human languages)~Scripting(quest xml language): these do NOT have the 'creation tags; your actions~events in quest
3. data~traits~characteristics~properties(physics)~adjectives~adverbs(human languages)~Attributes(quest xml language): these are hard to describe, as they're like a hybrid of Elements and Scripting.

-------

1. the 'creation' tag blocks

they have the '<xxx>xxx</xxx>' or '<xxx />' tags horizontally

or vertically:

<xxx>
xxx
</xxx>


here's an example of creating~adding an Object to your game, whether you do it in the GUI~Editor or in code, this will exist in code:

<object name="HK">
</object>


2. scripting

this does *NOT* have the '<', '>' tag stuff

as an example, here's the GUI~Editor's Verb adding~creation (you're actually adding~creating a Script Attribute for that Object), in code:

(find the code lines that don't have the '<', '>' tags: the 'fight' Script Attribute's content: the 'if~else' Script block)

<object name="HegemonKhan">
<attr name="alias" type="string">HK</attr>
<attr name="dead" type="boolean">false</attr>
<attr name="fight" type="script">
if (HK.dead) {
msg ("HK is already dead silly.")
} else {
msg ("You fight and kill HK.")
HK.dead = true
}
</attr>
<attr name="displayverbs" type="simplestringlist">fight</attr>
</object>

<verb>
<property>fight</property>
<pattern>fight</pattern>
<defaultexpression>"You can't fight that."</defaultexpression>
</verb>

jaynabonne
My advice: the best way to learn to write code (besides just doing it) is to read code others have written, preferably *good* code, to avoid rotting your brain and inheriting bad habits before you even get started. And a large body of well-written Quest code you have right under your nose is the core code that ships with the Quest desktop version. (If you're using the online version, then you can still view it all on the github site).

On my computer, the core files are the .aslx files under C:\Program Files (x86)\Quest 5\Core. That should be the standard install folder. If you installed elsewhere, you'll need to adapt the path. There are all kinds of areas to look at, so pick something that looks interesting. And if you don't understand it at first, don't worry. Just get a feel for how it looks and is structured; don't fret specific algorithms.

You can also look through the libraries posted in the forums and see how they're written.

Also, if you're fairly proficient in the GUI side of things, then I would write code in the GUI and then switch to code view and see how it looks. You'll find that there is a fairly simple mapping between the two. Once you learn what that is, then your GUI coding skills should translate fairly easily

HegemonKhan
let's create our own new game via directly in code:

--------------

here's what a new game's code looks like for reference for you:

<asl version="550">
<include ref="English.aslx" />
<include ref="Core.aslx" />
<game name="xxx">
<gameid>xxx</gameid>
<version>1.0</version>
<firstpublished>2015</firstpublished>
</game>
<object name="room">
<inherit name="editor_room" />
<object name="player">
<inherit name="editor_object" />
<inherit name="editor_player" />
</object>
</object>
</asl>


--------------

so, open up a new notepad, wordpad, or (preferably) notepad++, and save the blank file using the *.aslx extension (both your game file and~or any library files, use the same *.aslx extension)

notepad++ ( https://notepad-plus-plus.org/ )

once you downloaded and installed it, open~start it up, and within it, at the menu bar at the top of the screen, under the 'language' category, choose 'XML (eXtensible Markup Language)' as that is what quest code uses as its language. It'll color-code stuff for you, making it easier to read, write, and troubleshoot your quest coding.

-------------

INDENTATION ('nesting') IS VERY IMPORTANT, use the tab keyboard key for each level of indentation required (it's much better than using 2 spacebar keys... as I've learned the hard way, lol)

------------

first, create the 'asl' creation tag block

the 'asl' creation tag block is your entire game code, so everything has to be inside of it:

<asl> // the beginning tag of the 'asl' block
// your entire mass of game code
</asl> // the ending tag of the 'asl' block


the ' version="550" ' inside of the beginning tag of the 'asl' creation tag block, is the 'asl' creation tag's own Attribute, this version number has to match up with your downloaded quest.exe version, for the engine to be able to read your game code.

----------

now, add in the two required libraries:

English.aslx
Core.aslx

English.aslx sets the text to be in english
Core.aslx is actually a collection of many core files which make up the engine

the 'English.aslx' library file MUST come first (be above), before the 'core.aslx' library file, as this is the order that the quest engine builds itself up.

the 'include ref' creation tag lines are your library files that your game uses, the quest engine is actually a bunch of library files, so if you're really good at programming you can completely design your own quest engine, quest is that powerful~customizable !!!

<include ref="English.aslx" /> // beginning '<include' and ending '/>' creation tags on a single line
<include ref="Core.aslx" /> // beginning '<include' and ending '/>' creation tags on a single line


the 'ref="xxx.aslx" ' is the 'include' creation tag's own Attribute, which is what library file is gotten and used for your building up the quest engine and your game

note that your actual physical library files themselves (*.aslx) must be in the same folder as your quest.exe and~or your game file (*.aslx) ~ I get confused on this, thus the 'and~or', lol. This is required for these code lines to actually be able to get the library files for usability.

------------

next we add in the required special 'game' Game Object 'creation' tag block, which holds your global~game settings and a bunch of other related special stuff:

<game> // beginning creation tag
// Attributes
</game> // ending creation tag


the ' name="xxx" ' is the 'game' creation tag's own attribute, this is the name of your game.

the special 'game' Game Object is an Object, which means that it (as Objects) can hold~contain Attributes and~or other Objects.

the 'Object' Element: able to hold~contain Attributes and~or other Objects

the special 'game' Game Object, while it can hold~contain other Objects, it's not suppose to, as in the GUI~Editor, you can't add Objects into the special 'game' Game Object, so you shouldn't add Objects into the special 'game' Game Object, via in code, either.

the default Attributes of the special 'game' Game Object are:

<gameid>xxx</gameid>
<version>1.0</version>
<firstpublished>2015</firstpublished>

(look at the 'game' Game Object in the GUI~Editor, do you recognize the options~settings 'version' and 'firstpublished' ??? After you complete this code writing of a default new game code, try changing the version or firstpublished in the GUI~Editor, save your game file, then check your game's code, or vice versa, change the 'version' or 'firstpublished' in code, and see what happens in the GUI~Editor)

the 'gameid' is a required String Attribute, using some algorithm to randomly generate a unique string, as this serves as the 'ID' for your game. Like a car has a licence plate, or you have: a Driver ID card or a Social Security Number or DNA or fingerprint or iris pattern or voice pattern, etc etc etc

// note:
//
// the 'name' String Attributes are the 'ID" Attributes for quest, they MUST be unique.
//
// whereas, the 'alias' String Attributes don't have to be unique.
//
// for example:

<object name="orc">
</object>
<object name="orc">
</object>

ERROR!

VS

<object name="orc_1">
<alias>orc</alias>
</object>
<object name="orc_2">
<alias>orc</alias>
</object>

NO error


the 'version' (String or Double ~ not sure) Attribute and 'firstpublished' (String or Integer ~ not sure) Attribute, are just for your own documentation and information. Let's say I create a simple skeleton~bare bones game, leaving its version as '1.0', but then I go back and expand~improve upon my game, changing this version to being '2.0', basically it's a way for you to keep track of your game making's progress history. And 'firstpublished' is self-explanatory, lol.

well, let's add in some more Attributes via code (which we see in the GUI~Editor):

'attr' is used in code: conceptually it's short for 'attribute'
'int' is used in code: conceptually it's short for 'integer'

full code form:

<attr name="author" type="string">BenM</attr>

or it's (a String Attribute only) shortened code form:

<author>BenM</author>

recognize this Attribute? (see below)

in GUI~Editor:

'game' Game Object -> (whatever the Tab~s)

(Object Name: game)
Attribute Name: author
Attribute Type: string
Attribute Value: BenM

more Attributes:

<description>xxx</description>
<subtitle>xxx</subtitle>
<category>xxx</category>
<difficulty>xxx</difficulty>
<cruelty>xxx</cruelty>
// etc etc etc

for example:

// vertical placement of Attributes don't matter for the most part ~ there's a few exceptions, so long as those Attributes are placed within the correct Element (the correct Element creation tag block), via correct indenting~'nesting' ~ horizontal placement is VITALLY IMPORTANT), of course.

<asl version="550">
<include ref="English.aslx" />
<include ref="Core.aslx" />
<game name="testing game stuff">
<gameid>842278ef-87f7-4fa9-8a9f-7f81f2933f46</gameid>
<version>1.0</version>
<firstpublished>2015</firstpublished>
<author>HK</author>
<description>this is just a game file for testing stuff</description>
<subtitle>HK's testing stuff game file</attr>
<category>Simulation</category>
<difficulty>Easy</difficulty>
<cruelty>Merficul</cruelty>
</game>
<object name="room">
<inherit name="editor_room" />
<object name="player">
<inherit name="editor_object" />
<inherit name="editor_player" />
</object>
</object>
</asl>


-------

now, let's add in the 'room' Room Object:

<object name="room">
// Attributes and~or other Objects
</object>


again the ' name="xxx" ' is the 'object' creation tag's own Attribute

and remember, the 'Object' Element holds~contains Attributes and~or other Objects

the 'inherit' Inherited Attributes add that Object Type (and all of its Attributes) to the Object, but let's not get into Object Types (quest's Classes~Groups), for now.

let's add an 'orc_1' (non-room and non-player) Object to our 'room' Room Object:

<object name="room">
<inherit name="editor_room" />
<object name="orc_1">
<inherit name="editor_object" />
</object>
</object>


and let's add an 'alias' String Attribute to the 'orc' Object:

<object name="room">
<inherit name="editor_room" />
<object name="orc_1">
<inherit name="editor_object" />
<alias>orc</alias>
</object>
</object>


and let's add a 'dead' Boolean Attribute to the 'orc' Object:

<object name="room">
<inherit name="editor_room" />
<object name="orc_1">
<inherit name="editor_object" />
<alias>orc</alias>
<attr name="dead" type="boolean">false</attr>
</object>
</object>


// a shortened form for *all* Attributes is this:
// <attribute_name type="attribute_type">Value_or_Expression</attribute_name>
//
// for example using the 'dead' Boolean Attribute:
// <dead type="boolean">false</dead>
//
// ----------------
//
// and another shortened form *ONLY for 'true' Valued* Boolean (and Inherit too) Attributes (using the 'dead' Boolean as an example):
// <dead />
// is the same as: <dead type="boolean">true</dead>

and let's add a 'description' Script Attribute to our 'room' Room Object:

<object name="room">
<inherit name="editor_room" />
<alias>orc</alias>
<object name="orc_1">
<inherit name="editor_object" />
<attr name="dead" type="boolean">false</attr>
<alias>orc</alias>
</object>
<attr name="description" type="script">
if (orc_1.dead = true) {
msg ("There's a rotting dead orc corpse in the room with you.")
} else if (orc_1.dead = false) {
msg ("There's an orc in the room with you... you better kill it... or it will likely kill you!")
}
</attr>
</object>


so, what we got in full now:

(I am, and have been a bit previously, intentionally switching things around vertically, so you can see that it doesn't matter, long as you do it right)

<asl version="550">
<include ref="English.aslx" />
<include ref="Core.aslx" />
<game name="xxx">
<gameid>xxx</gameid>
<version>1.0</version>
<firstpublished>2015</firstpublished>
<author>HK</author>
<description>this is just a game file for testing stuff</description>
<subtitle>HK's testing stuff game file</attr>
<category>Simulation</category>
<difficulty>Easy</difficulty>
<cruelty>Merficul</cruelty>
</game>
<object name="room">
<inherit name="editor_room" />
<attr name="description" type="script">
if (orc_1.dead = true) {
msg ("There's a rotting dead orc corpse in the room with you.")
} else if (orc_1.dead = false) {
msg ("There's an orc in the room with you... you better kill it... or it will likely kill you!")
}
</attr>
<object name="player">
<inherit name="editor_object" />
<inherit name="editor_player" />
</object>
<object name="orc_1">
<inherit name="editor_object" />
<alias>orc</alias>
<attr name="dead" type="boolean">false</attr>
</object>
</object>
</asl>


---------------------

and... I think you can now add in the default 'player' Player Object (a Player Object is REQUIRED) from here... and hopefully anything~everything else now too... maybe... hehe :D

---------------------

lastly, let's briefly show you the 'Function' Element, by having you put one in:

the 'Function' Element: holds~contains Scripting

// the GUI~Editor's 'Verb' Element: holds~contains Scripting through (and only for~with) a specific Object
// a Function is somewhat similar to your use of the GUI~Editor's 'whatever' Object's 'whatever' Verb, but let's ignore more explanation of Functions, other than what I hope you will gleam from testing~seeing~studying~playing with below:

(look at the entire code below, to see everything that you need to add in)

<asl version="550">
<include ref="English.aslx" />
<include ref="Core.aslx" />
<game name="xxx">
<gameid>xxx</gameid>
<version>1.0</version>
<firstpublished>2015</firstpublished>
<author>HK</author>
<description>this is just a game file for testing stuff</description>
<subtitle>HK's testing stuff game file</attr>
<category>Simulation</category>
<difficulty>Easy</difficulty>
<cruelty>Merficul</cruelty>
</game>
<object name="room">
<inherit name="editor_room" />
<attr name="description" type="script">
function_1
if (orc_1.dead = true) {
msg ("There's a rotting dead orc corpse in the room with you.")
} else if (orc_1.dead = false) {
function_1
msg ("There's an orc in the room with you... you better kill it... or it will likely kill you!")
function_1
}
function_1
</attr>
<object name="player">
<inherit name="editor_object" />
<inherit name="editor_player" />
</object>
<object name="orc_1">
<inherit name="editor_object" />
<alias>orc</alias>
<attr name="dead" type="boolean">false</attr>
</object>
</object>
<function name="function_1">
msg ("blah blah blah")
</function>
</asl>


----------------------

computers and hackers can read this (horizontal code structure), but we code noobs can't (we like our vertical code structure), lol:

<asl version="550"><include ref="English.aslx" /><include ref="Core.aslx" /><game name="xxx"><gameid>xxx</gameid><version>1.0</version><firstpublished>2015</firstpublished><author>HK</author><description>this is just a game file for testing stuff</description><subtitle>HK's testing stuff game file</attr><category>Simulation</category><difficulty>Easy</difficulty><cruelty>Merficul</cruelty></game><object name="room"><inherit name="editor_room" /><attr name="description" type="script">function_1 if (orc_1.dead = true) { msg ("There's a rotting dead orc corpse in the room with you.") } else if (orc_1.dead = false) { function_1 msg ("There's an orc in the room with you... you better kill it... or it will likely kill you!") function_1 } function_1</attr><object name="player"><inherit name="editor_object" /><inherit name="editor_player" /></object></object><object name="orc_1"><inherit name="editor_object" /><alias>orc</alias><attr name="dead" type="boolean">false</attr></object><function name="function_1">msg ("blah blah blah")</function></asl>

jaynabonne
My personal take: use the GUI for as much as you can. What I mean by that is, use the Quest GUI to set up as much of the boilerplate skeleton for things as you can. Why manually add in all the things the GUI will do for you for free?

As an example, if I'm going to make a new command, I don't jump into code view and start to code up a <command> tag. It's just not worth it to me (plus my memory is not as good as it used to be). Rather, I'll create a new command in the GUI editor, fill out the fields, and then where the script will be, I just add a single "Print Message" with text like "xxx". That will set up the skeleton for the command.

Then I switch to code view, find the "msg("xxx")", delete it and begin writing my script. There's a lot you can do via the GUI to make your life easier (except the scripting part - I find creating script in the GUI editor tolerable for small things only and practically impossible for anything complex).

So I recommend: use the GUI for all of your game structuring. Use code view (or a text editor) almost exclusively for writing scripts. Of course, copy and paste works as well, if you have existing elements you want to duplicate somehow... :)

And HK: it's not just NOOBS who prefer properly formatted code! The goal, at least with professional programmers, is to write code FOR HUMANS, as we're the ones who have to maintain, extend and fix it.

HegemonKhan
oh definately, for programmers in a company~business~firm~job~etc (though they don't want it outside of that group: ie OSes are encrypted, and maybe some don't want to be in such a group sharing their IP to that group as that code of theirs could be worth a lot of money, they'd rather have the money themselves, and not the entire company profiting off of their ip or other individual persons ~ it's really not fun when someone steals your IP and makes a fortune off of it... lots of such very famous examples in history... of many different types of IP too ~ other fields of science and non-science fields too, not just source code IPs),

though, if you're not writing code for others... if you don't want others to be able to easily read~know what your code is or is doing and how it is doing it... you write in machine language, encrypt it, protect it ('trap~counter malware or barriers'), hide it (secret additional code in things people don't suspect like within a picture that a pdf uses), and etc... laughs. The more unlawful or 'black' but lawful programming... where the goal isn't cooperation... but a personal interest...

jaynabonne
It has absolutely nothing to do with corporate vs personal projects.

When I said HUMANS, those who have to maintain, extend and fix code, I assumed you'd know that even individuals are considered human beings as well, and we have to do all of the same tasks even when working solo. Writing code in gibberish form will only hurt you down the road when *you* come back to it later. Good clean coding practices apply across the board.

Granted, if you need to somehow encrypt your code - if what you're writing is so top secret that you don't want others to know about it - then you have to resort to all sorts of things to make that happen, and simply removing white space is not going to do it. (So what you posted above would make a hacker laugh). Also, that can happen whether you're working solo or in a company. (For example, I was responsible at an earlier job for "tamper-proofing" our CSS implementation for DVD playback.)

Obscuring code is only done for specific reasons, which have nothing to do with whatsoever with personal or solo projects vs larger scale ones. It's all the same, just on a different scale or perhaps with different compensation.

HegemonKhan
I'm just trying to enter the computing+programming field... though I've seen some instances of hackers ~ good programmers monitoring~reading~scanning horizontal code across a screen (such as code dealing with networking stuff~activity I presume or whatever possibly else) such as in looking for malicious intrusions~attacks upon their servers~etc, whereas it's very difficult for most people to do so, so this is my basis for my posts. I am aware of everything your saying too. I wasn't saying that horizontal code is any sort of deterant, though I didn't really explain until now was more from the basis of monitoring code, that good programmers can look at that stream of horizontal code and see any out-of-place code within it.

jaynabonne
Ok, I can see that, and perhaps I missed the nuance in what you were saying - more experienced programmers certainly can *read* such things. But I would not go so far as to say that NOOBs are the only one who *prefer* well written code, especially at the time it's being written. :)

I used to love perusing binary dumps of file formats. It's like trying to work out a puzzle. Then I'd go back and write some nice readable code to make it work. lol

I was just worried that you saw unformatted, blocky code as a sign of a non-NOOB (i.e good programmer). I just want to be sure you know it's not the case, and no one should aspire to writing stuff like that.

HegemonKhan
I wasn't very clear in my posts... and I was being a bit over-dramatic too, in trying to emphasize that good programmers ~ hackers can make sense of horizontal code better than we 'noobs' can, as we're the noobs, and they're the pros, having seen+done lots of coding (and advanced coding), whereas we've not.

-----------

anyways one of my references was this tv documentary on one of our really top hackers... who was an unlawful hacker, but eventually got caught, and of course instead of going to jail now works for the government~corporations as a good guy now. For me it was really astounding at what he could do... seeing a glimpse into the programming world... programmers (and especially hackers, the best of the best of programmers) are really amazing... sighs.

jaynabonne
To be clear, I don't know if I would call hackers "the best of the best of the programmers". I would say hacking and programming are two different (but related) things. I would bet you could be a truly excellent hacker - maybe even the best - and not necessarily be able to write decent, good code. (By "hacker" I'm assuming you mean those who break into systems.) The skills may exist simultaneously in individuals (and one can lend itself to the other), but they are not coincident skills by any means.

And, yes, it is fascinating stuff. :) I have often wished to go into cyber security.

Pertex
In german "hacking" is a synonym for writing functional but bad code :D This is not wrong basically . if I just need a short script I don't think about pretty code

jaynabonne
There is a great book called "Hackers", which has the original meaning for a "hacker": someone who likes to go deep into a system. That system could even be the menu at a Chinese restaurant (to use an example they had in the book)... Interesting stuff - and interesting how usages change over time.

XanMag
And the OP has fled... Lol

jaynabonne
XanMag wrote:And the OP has fled... Lol


"Uh, maybe I don't actually want to write code, if this is what it does to people..."

(lol)

HegemonKhan
my use of hacker:

is a person who knows computers, tons of software, networking, and etc, inside and out. All levels of computing is known by a hacker, they're the most knowledgeable and thus the best, able to have unbreakable security and break into any security, due to their deep~full understanding of all levels of computing, their devices, networking, computer systems, and etc, should they choose to do so, for lawful purposes or unlawful purposes. They intimately know every aspect about anything and everything related to computers. They are the experts of the experts in computing, able to find vulnerables that no one else could even have imagined, and to secure their own computers and networks in ingenius and unbreakable ways and numerous layer upon layer of security.

the best hacker in the world:

Motoko Kusanagi :D

2nd best hacker:

The laughing Man

3rd best hacker:

Gouda

Pertex
HegemonKhan wrote:my use of hacker:

is a person who knows computers, tons of software, networking, and etc, inside and out.


We call them nerds :lol:

jaynabonne
[I hope I'm not taking this too seriously, considering your top choice for hacker is an anime character. lol]

I don't want to drag this on too much longer, HK, but nowhere in your description did you mention programming. I do admit that there are people out there who do know computers inside and out, who *know* just about anything you'd want to know about computers, who can do all the things you say. But that's not crafting software. They can work their way in and out of Linux, maybe even making changes to Linux on a software level - but they couldn't have written Linux. They can move around inside Windows, writing small back doors, setting up security settings, installing software packages (all based on an extensive knowledge of the security world, what's out there, what need to be done, how people can break in) - but they couldn't have written Windows. They know how to find holes in a security system in a way that causes the government concern, but they've never written a computer game or a word processor or scientific analysis tools or automobile or plane control systems or anything larger than a fairly extensive script.

Those examples probably seem a bit trite, and I wish I could convey what I'm trying to say in a better way.

There are undoubtedly hackers who are excellent programmers. All I'm saying is they don't go hand in hand necessarily.

I have interviewed perspective job candidates with PhD degrees in computer science, people who have studied for years and know all sorts of things to do with CS (hardware, software, algorithms, etc). They can tell you how computers work on a hardware level. They can tell you which algorithms have which "big-O" behavior - and yet they can't write software. Why? Because writing software is not *knowing*. Writing software is *doing*. And it's something (just like anything else) that you have to do for a long time to get really good at. They say 10,000 hours for anything... Hackers have spent their 10,000 hours learning all about computer systems, learning where the holes are, learning how to create and defeat security, learning how the hardware is set up, learning about social engineering (e.g. how to get passwords out of people), learning how to cover their tracks, learning how to tweak this file or that, learning how write scripts to do god knows what, learning all that and so much more, so much more than I'll ever know, for example - but unless they've put in the time actually *writing software*, and I mean a long time writing large scale things (either on their own or for employ), then they will never be able to be considered the best of the best in terms of *programming*. Because programming is about *creating*, it's as much a craft as writing or painting or sculpting. And it's as much engineering as we can make it. lol

You may disagree with me, and that's fine. I just hope you realise that I've seen programming over decades of employment in a way that you might not have yet. And I can only hope that as you get more skilled, you will get involved in some really meaty projects that will show you just what it's all about when executed at a higher, more refined level.

A thief who has spent his whole life (say) breaking into buildings, either for gain or not, someone who knows how buildings are put together (and so knows some architectural engineering), someone who knows how security systems work (and so knows some electrical engineering), someone who can study the work habits of the people in n high-rise building to figure out the best time to make an attempt (and so knows some social engineering), and all sorts of other arcane things build up from an incredible amount of experience gained over a long period of time such that they can enter and move through any building they wish - such people are amazing and unsurpassed at what they do.

But they'll never be Frank Lloyd Wright.

They'll never be involved in actually engineering a building, to have to worry about all the details you have to worry about to make sure it all doesn't fall down when you're done.

They may never even be involved in the actual building of anything of substance, being involved in all the minute step by step you have to go through, pouring concrete, making sure how it dries, securing bolts, welding metal, making sure the joins are done properly...

They are amazing at what they do, but they will quite possibly never *create*.

Of course, there are undoubtedly those who can and do. But "hacker" does not equate necessarily even with "programmer", let alone the best of the best of. (I'm sure you can find examples of those where it does overlap. I'm not saying their exclusive.)

"And that's all I have to say about that." (Forrest Gump voice)

[Hey! This is post 2222 for me. Not sure what it means... Ok, it doesn't mean anything. But it's a number, nonetheless.]

HegemonKhan
thanks Jay for explaining more about programmers, still quite a layman, I always assumed that in being able to do all the hacking stuff, hackers must've a good sense with programming, as to me their hack programming was the same as programmers' programming. For a layman like myself, "programming~coding was programming~coding" until you've helped enlighten me in these last few posts, I now see that's not the case. Programming used for hacking is very different than programming for software creation. As ingenius as some hacks may be... they're not an entire super advanced, complex, and vast system that programmers create as software environments.

This topic is now closed. Topics are closed after 60 days of inactivity.

Support

Forums