• Ron Fox (google)

    Your code might be unmaintainable: If it has a five line regular expression with no comments above or below.

  • PWolff (nodebb) in reply to Ron Fox

    Or any regular expression with more than 5 nested levels of parentheses without more lines of comment than pairs of parentheses, as for this.

    (Btw, "might be unmaintainable" looks like a terminal case of understatement, as usual.)

  • PWolff (nodebb)

    Your code might be unmaintainable if the dev team speaks of it like of a living creature, like, "you have to live up to its whims"

    Disclaimer: By no means do conclude I would be talking out of experience ;(

  • dkf (nodebb)

    Your code might be unmaintainable if it is relying on website redirects for access control rules.

  • Quite (unregistered)

    ... if every single member of your team lives and works in a different country.

  • PWolff (nodebb) in reply to Quite

    I suppose you don't mean

    developer A: born in Italy with Albanian parents, living in Belgium, working in an office in Germany, on a code base hosted in Sweden...

  • Greg Trevellick (unregistered)

    ...if there's a zillion magic strings in your codebase.

  • Greg Trevellick (unregistered)

    ...you have multiple hand-cranked classes with 5 or 6 figure line numbers

  • PromotedGuy (unregistered)

    Re: "Your code might be unmaintainable if Microsoft Access forms a critical part of your business workflow. Or Microsoft Excel. Bonus points for unreadable Excel macros that fall victim to other traps in this article" -- been there there done that. I became responsible for maintaining a system like that after being promoted from Junior VB Programmer to IT Coordinator (top-level IT Manager) a few days after being hired since the IT Coordinator who hired me resigned the same week he hired me and they looked at me and said "well, you're an IT guy, we'll just give you the IT Coordinator position, you'll figure it out! Now if anything computerized across our four factories and network of 100's of computers in the city breaks it's now your responsibility to fix it..." Of course, there was no increase of salary to match the drastic increase in responsibility (as seems to be the defacto standard business practice these days...).

  • Greg Trevellick (unregistered)

    ...if your code coverage percentage is nil. Bonus points if, when you add your first test, the code coverage percentage only reaches 0.0001%.

  • Steve_The_Cynic (nodebb) in reply to Greg Trevellick

    I once worked on a code base (about 60 million lines of code when I started) where one particular C file, hand written, no less, was over 1.6 MB. Editors (both software and human) didn't like it very much, since it was, needless to say, many, many thousands of lines long.

    But that wasn't the worst thing I ever saw in that code base, and neither was the three-quarters of it, in 2004, that were still in Fortran.

    No, the worst was the file that housed a piece of production code. The name of the file was the name of a certain 1981 film directed by Sam Raimi, and the variables and internal functions were all named after references to the film of one sort or another.

  • chreng (unregistered)

    Your code might be unmaintainable if your new boss tells you that the guy who wrote it was a genius.

  • Steve_The_Cynic (nodebb)

    I like the way the article separates 8.5"x11" and A4 as if the difference in size between them is meaningful. A4 is a metric size, but in "old money" it is roughly 8.27"x11.67" (210mm x 297mm), or not much different from USLETTER.

    However, if the diagram is still unreadable on A2(1), then you have a real problem. For ... reasons ... I used to own an A2 flat-bed scanner. It was monstrously heavy and, even as "last year's" model, it was uncomfortably expensive, but it was immensely fast compared to the ordinary HP consumer-grade A4 scanner it replaced, to the point where it could scan a full sheet of A2 at 200dpi in less time than the HP used to take at the same dpi for A4.

    (1) A2 is twice the area of A3, which in turn is twice the area of A4. All three sizes (and the related A5, A6, A1 and A0) are the same shape (1:sqrt(2)), so A2 is twice as long and twice as wide as A4.

    I eventually had to get rid of it, when the software decided it needed to be calibrated, and the calibration "card" didn't work and couldn't be replaced, and the scanner was left in a calibration-free state.

  • Old Hack (unregistered)

    Your code might be unmaintainable if the programmers give it nicknames like “the monster” or “the barge” or utter the words “there be dragons”

    Or the only comment reads "You are not expected to understand this."

  • Appalled (unregistered)

    Your code have Sets and Gets that do anything order than simple Assignment.

    I ran across a case once where the Gets had Database IO Logic (Selects to compute Credit worthiness for the Customer from AR History). It was used up to 6 times per Order Detail Transaction, new line or changed line, since the successors assumed it was a simple assignment.

    Now my question, has anyone ever seen a Setter with Database Update logic? What a nightmare that would be. "How the Hell did we start double counting everything?"

  • Kath (unregistered)

    Your code might be unmaintainable if it was built in 1974.

  • DCRoss (unregistered)

    You're talking about Discourse again, aren't you?

  • Mason Wheeler (unregistered)

    Your code might be unmaintainable if management dictates the design of the codebase – down to the nitty-gritty tactical level. Bonus points if the manager is a non-technical VP who responds to criticism by firing the developer on the spot.

    I guess I've just been lucky. Every manager I've worked so far has been a reasonably competent developer. Only one of them was a micromanager. Guess which job I stayed at the shortest length of time?

  • PWolff (nodebb) in reply to Kath

    The code being in COBOL does by no means say it would be unmaintainable. (It just means that today's kids can't make anything of it)

    And in the 1970s, a CPU minute was so expensive that it was cheaper to write, syntax check and function test (!) the code by hand before submitting it to the compiler. And if your fellow coder couldn't understand your code, you were frowned at, and if you couldn't even explain it within the time you need to write it down, you were in serious trouble.

    (Not that the Good (R) Old (TM) Times (Pat. Pend.) were really better than today, just different.)

  • your name (unregistered) in reply to Mason Wheeler

    In my case I had the fortunate event of learning that my micromanager was fired. Alas, one year too late

  • Tommy Phillips (google)

    ... if you find a bit of shell script that accidentally works, and has been re-used by copy/paste/modify in a dozen other scripts. Bonus points if half of them have added individual functionality that makes it impractical to collapse them to a single parameterized script.

  • Tommy Phillips (google)

    ... if you have shell scripts whose sole purpose is to call a different shell script with a particular parameter, from a job control system that allows specifying parameters.

    You know, like this:

    RUN_XYZ_REPORT_ABC: #!/bin/ksh

    RUN_XYZ_REPORT ABC

  • Paul Neumann (unregistered)
    Comment held for moderation.
  • garrett (unregistered) in reply to Steve_The_Cynic

    I have a 20mb "auto generated" class in one of my projects at work. I put "auto generated" in quotes because it was auto generated from a WSDL a few years ago by someone else, and has been modified since. It's terrible. I hate it. Visual Studio hates it. It's like 600k lines and it kills a piece of me every time I have to open it.

  • _that_guy_ (unregistered)

    What's wrong with running proprietary code in your langauge? Internet of Things has to start somewhere, right?

  • Joseph Osako (google)

    TIL about developing in FoxworthyPro.

  • RedskullDC (unregistered)

    .... if your see a comment like this in the codebase...

    #do not delete the next 2 lines even if you think they #should not be there - I forgot myself and I only wrote #the code 5 minutes ago !!! "(C) Nino 1986-2003"

  • Microsoft (unregistered)

    Your code might be unmaintainable if it’s full of comments that simply read //BUGBUG.

    That's not fair. We intentionally designed inf files to discourage amateurs from fiddling with them.

    So what if we hired some amateurs who fiddled with them, and sometimes we had to ask customers for help "//BUGBUG: What does this do?"

  • Microsoft (unregistered)

    manual functional testing can be one of the most boring parts of software engineering

    Thank you for your understanding. Now you know why we eliminated the parts of software engineering that generated the most complaints.

  • AgentDenton (nodebb)

    ... if you have nested blocks of code in a single line.

    ... if you have complex Linq queries in one line.

    ... if you have foreach statements that contain said complex Linq queries as the collection to iterate through.

    ... if you have to write (large) sections of code as text, because it needs to be eval-ed at runtime.

    ... if you have nested ternary expressions.

    ... if you have nested ternary expressions in a single line.

    ... if you have a class of about 3000+ lines, and about 2800 is treated as a single statement in the debugger.

    All of these (and more) I've experienced at my previous employer. Their vendor had a knack for writing such code. Bugs were usually simple to fix, after spending a ton of time on investigation.

  • cheong (nodebb)

    Your code might be unmaintainable if you are unable to find the source code! …in a folder marked DEV_BACKUP_2013

    Think about the business which don't use source control at all. Having backup(s) in some folder can already be considered a luxury.

  • cheong (nodebb)

    Your code might be unmaintainable if you are unable to find the source code! …in multiple folder marked ProjectName [b]in file server folder of different user... with visual difference on the folder/file datetime only[b]

    This variant is a different kind of hell.

  • AstorLights (google)
    Comment held for moderation.
  • Steve_The_Cynic (nodebb) in reply to garrett

    Yeah, that's a problem, but the 1.6MB file I mentioned was written by hand.

  • Steve_The_Cynic (nodebb) in reply to cheong

    You say this, but the same place that had the 1.6MB C file also had several compiled object modules for which the source code had been lost. As in, like, no trace of it remained, but the compiled code was still in production.

    It caused ... issues ... when they tried to port to a new CPU architecture. They even went so far as to write and/or obtain a binary-to-binary compiler that could transcode machine language for the old CPU type to the new CPU type. For other reasons, the new machines didn't perform, so the porting effort was abandoned.

    In its place, they instituted an effort to write replacements for the lost-source modules. The whole episode was a bit scary.

  • GorGutz 'Ead 'Unta (unregistered)

    Your code might be un-maintainable if you use a coding standard from 20 years ago that they refuse to upgrade from not because it would screw everything up, but because the old guard has a crazy fixation on that particular version of whatever the fuck.

    Either that or if you use something that doesn't support comments. I'm sorry, but I just can't stop thinking about that article. What kind of retard system doesn't allow commenting? Did the designer expect people to keep notes on what everything did separate?

  • .net core projecteer (unregistered) in reply to GorGutz 'Ead 'Unta

    json

  • New job...please for the love of God (unregistered)

    Your code might be unmaintainable if:

    • it uses an "open source" data access layer for which no source code is traceable on the internet because it went out of support 14 years ago (ten years before the code using it was written...).

    • All 99 projects are in one single monolithic Visual SourceSafe solution, although the solution as a whole won't compile because some of the projects are redundant, some of them are duplicates and some of them are unfinished projects that contain errors (but, for reasons which will become apparent, it isn't entirely clear which projects fall into which category).

    • It was written by two different amateur programmers (i.e. programmers with no formal training and no previous commercial coding experience and without guidance from any commercial programmer) at different times, with completely different technical approaches to the same basic problems. One of them had heard of OO but didn't know how to do it.

    • There are so many dependencies between components and so many overlaps of concerns that it's impossible to separate out any individual component (or even group of components) for individual unit testing.

    • The same programmers designed the data model. Neither was a data analyst or understood what they were doing. The data model is hopelessly, jarringly wrong and looks as though they thought Bill Karwins "SQL Anti-patterns" was a "how to" guide.

    • There is not ONE SINGLE LINE of documentation. No requirements (busines or otherwise), no specs, no test plans, no code comments, no notes, no emails. Nothing.

    • One in every three variable names contains at least one misspelt word just to provide a constant grating distraction from understanding what the code is actually doing

  • Hack (unregistered)

    Your Code Might Be Unmaintainable if your methods create an empty text file then rely on task scheduler to periodically check for said text file with a hard coded name to start a third party application to complete a task that could be finished in one line of code in the original application. Bonus points if you don't comment the code or validate the task completed.

  • Paul M (unregistered)

    You code might be unmaintable if you run it through a linting program and you fix the first error and the score goes lower.

    I inherited some code with a pylint score of about 4, so bad that pylint bailed out. I fixed the first two or three things and ran pylint again, and the score became negative!

  • isthisunique (unregistered)

    Your code might be unmaintainable if it's not your code.

  • isthisunique (unregistered)

    Your code might be unmaintainable if you actually have to maintain it.

    Your code might be unmaintainable if you have to delete significantly more than you add.

    Your code might be unmaintainable if more than 95% code coverage for individual functions is impossible.

    Your code might be unmaintainable if half of it is commented out.

    Your code might be unmaintainable if identifiers use uppercase, camelcase, underscore and lowercase multiwords are the same time.

    Your code might be unmaintainable if you find a file with more than 5000 lines.

    Your code might be unmaintainable if when you inherited it all of the previous developers had moved on.

    Your code might be unmaintainable if developers rewrite functions such as "registerUser" and append the suffix "Sanely" to them.

    Your code might be unmaintainable if a developer rewrites a 1000 line file in under 100 lines.

    Your code might be unmaintainable if it has more bugs than features.

    Your code might be unmaintainable if the letters C, V and CTRL are worn off your keyboard.

    Your code might be unmaintainable if you turn on warnings and suddenly run out of disk space.

    Your code might be unmaintainable if parts of it are written in Klingon, test speak, leetspeak or otherwise.

    Your code might be unmaintainable if you have to break it to fix it.

    Your code might be unmaintainable if writing code from scratch is quicker than fixing code.

    Your code might be unmaintainable if you're still working on it full time years after delivery.

    Your code might be unmaintainable if opening it crashes or hangs your IDE.

    Your code might be unmaintainable if sleep is considered a good way to wait for something to finish.

    Your code might be unmaintainable if your developers are paid per line.

    Your code might be unmaintainable if your developers always say yes.

    Your code might be unmaintainable if your developers always say no.

    Your code might be unmaintainable if only one developer ever worked on it for years without expert supervision or verification.

    Your code might be unmaintainable if it escapes data for display before storing it rather than before displaying it.

    Your code might be unmaintainable if there's enough deadcode to call it a graveyard.

    Your code might be unmaintainable if any of your developers rage quit their job.

    Your code might be unmaintainable if any of your developers is seeing a psychiatrist.

    Your code might be unmaintainable if any of your developer has committed suicide.

    Your code might be unmaintainable if it doesn't use VCS.

    Your code might be unmaintainable if you never hire developers for more than a cleaner's salary.

    Your code might be unmaintainable if you can only edit it in production.

    Your code might be unmaintainable if you have to patch your interpreter to make it work.

    Your code might be unmaintainable if you tell your developer that they are using the wrong operator and they ask you what is an operator.

    Your code might be unmaintainable if your developer downloads a crack for software rather than asking for a license.

    Your code might be unmaintainable if your keep hearing the word legacy.

    Your code might be unmaintainable if your developers often point out code as worthy of the DailyWTF.

    Personal:

    Your code might be unmaintainable if a week in an outsourced developer messages your that they dropped the main production database.

    Your code might be unmaintainable if you find that they used PHP serialize to send the whole product database to javascript on every page and then used a javascript library for PHP's serialize format to decode it.

    Your code might be unmaintainable if the developer did not understand the difference between frontend/backend and tried to implement long polling by having a file require itself using the fopen url wrapper and http to localhost.

    Your code might be unmaintable if a simple select count from a where not in b query consists of subqueries to a depth of three, takes an hour to run with 100 items in each set, breaks when in b but not a, returns multiple rows and only uses the first.

    Your code might be unmaintainable if you find the fix for a user even if it was the guest user to see a public user page was not to set the permission to public but to first add each visiting user to the allow list for the user they are viewing and to redirect back to the page.

    Your code might be unmaintainable if you get a sysadmin ticket from an outsourced webdeveloper enquiring as to why downloading ffmpeg.exe from tucows and then uploading it to a Linux server and running it doesn't work and you notice that none of the input is validated and none of the arguments are validated.

    Your code might be unmaintainable if your site is distributing malware because your entire outsourced development team got a virus that appends a payload to any file with a web extension they find which they later upload via FTP.

    Your code might be unmaintainable if it includes 2GB of library dependencies and only uses 5MB of the code.

  • isthisunique (unregistered)

    One more personal:

    Your code might be unmaintainable if to duplicate and rebrand a website the codebase has been copied with the required changes being made naively and haphazardly by a regexing reverse proxy.

  • isthisunique (unregistered)
    1. Yet more personal from a job I left after two weeks not of my own accord but definitely to my own relief:

    Extreme TDD:

    Your code might be unmaintainable if in the first week you ask for documentation that due to stress and being overworked you naively print then when you go to the printer an hour later to your horror you find you've printed a four inch pile of manual test cases.

    God class:

    Your code might be unmaintainable if you find a God class with tens of thousands of dense lines in a scripting language.

    Layers of insanity:

    Your code might be unmaintainable if every view starts of by defining a model class and then when you investigate the models you find three layers of unnecessary indirection, that every filed is copy-pasted for each table or join to the point of a cartesian product including every possible method needed in one model repeated but renamed appropriately across ever class in case they might need it which mostly they didn't named such as class user method addUser creating pointless variation rather than using parameters or inheritance and with a try catch any exception in every method body setting an error property when catching any exception and for every method called on an object further down in the layers of indirection checking the error property then immediately throwing an exception if an error was present.

    Getting started:

    You code might be unmaintainable if you setup a new install of the codebase locally and it takes ten seconds to load each page because the permissions system somehow has to iterate millions of times and recurse to depths in the hundreds even with only one user in the database and a few rows.

    Getting help:

    Your code might be unmaintainable if you ask the author for help and they can't figure out what is happening.

    Got help:

    Your code might be unmaintainable if you ask the author for help getting the application running and they have you copy their database because it just works and they don't know why.

    But then management:

    Your code might be unmaintainable if you hire a real developer who is willing to stick around despite the horror unleashed upon then to assist the current developer who has clearly been struggling only to fire them after two weeks because they did not attend an optional meeting.

    1. Random personal:

    Your code might be unmaintainable if your bash scripts exports env from the pid folder in proc derived by grepping ps for clockwidget without any checks for failure to run X11 commands.

    Your code might be unmaintainable if each page requires jquery, mootools, prototype, YUI, script.aculo.us and Dojo.

    Your code might be unmaintainable if development only started 6 months ago and it uses libraries that are 6 years old.

    1. Strangely good job but left me guessing more than learning, cutting corners until there were none left to cut and burnt out:

    Your code might be unmaintainable if you give your developer a list of tasks each day and assign exactly 5, 10, 15, 30, 45, 60 or 120 minutes to complete each one using the times taken for tasks by the developer who has been working on the project for at least a year as the standard immediately after starting the job for a large codebase and technology stack that takes two to three months to come accustomed to (somewhat less for someone more familiar with the technology stack).

    1. More general:

    Your code might be unmaintainable if you also value the quickest solution the most.

    Your code might be unmaintainable if it is using alpha, beta or RC software dependencies.

    Your code might be unmaintainable if it is using new rather than tried and tested technologies.

    Your code might be unmaintainable if you try to copy Facebook or Google.

    Your code might be unmaintainable if you worry more about filling a seat to replace a departed developer than hiring someone who can do the job.

  • isthisunique (unregistered)

    There is more. I have to squeeze out every last drop of resentment that has built up over the years:

    Correction: Also -> Always, there's another but I lost it.

    Your code might be unmaintainable if your developers use edit, notepad.exe or wordpad as their IDE.

    Your code might be unmaintainable if you drip feed requirements to your developers.

    Your code might be unmaintainable if it has been hacked multiple times.

    Your code might be unmaintainable if you recreate the same application five times from scratch just to implement a different theme using worse developers each time and getting worse results each time when you have a perfectly good codebases that can be copied.

    Your code might be unmaintainable if developers have to decompile it because the source has been lost.

    Your code might be unmaintainable if your developer refuses to accept criticism.

    Your code might be unmaintainable if the previous developer moved into a less hands on technical field.

    Your code might be unmaintainable if you forked it from unmaintainable code.

    Your code might be unmaintainable if you went for the lowest bidder.

    Your code might be unmaintainable if suppresses warnings or errors.

    Your code might be unmaintainable if there are ten copies of the source code and no one knows which is the most recent.

    Your code might be unmaintainable if your developer smokes weed every day outside the main entrance of the building.

    Your code might be unmaintainable if you ignore code quality entirely and compensate with a guantlet of testers, support and firewalls.

    Your code might be unmaintainable if you outsource to a country with a terrible standard of education.

    Your code might be unmaintainable if good developers keep leaving.

    Your code might be unmaintainable if it has files named .bak or user.c, user1.c and so on.

    Your code might be unmaintainable if it stopped on production and when you try to run it you find five versions of the compiled executable spread across the system and when you finally discover that there are shell scripts to start the process one is called gO and the other g0 which look almost entirely identical in your shell.

    Your code might be unmaintainable if database tables are designed like spreadsheets rather than a relational model.

    Your code might be unmaintainable if your database has no foreign keys, unique constraints or primary keys.

    Your code might be unmaintainable if you have a team doing a one man job.

    Your code might be unmaintainable if you have a one man team doing a ten man job.

    Your code might be unmaintainable if your developer is running a production server from his closet

    Your code might be unmaintainable if your standard is as long as it works.

    Your code might be unmaintainable if you have no coding standard.

    Your code might be unmaintainable if you have no coding convention.

    Your code might be unmaintainable if this is the first time you've heard about the concept of code maintainability.

    Your code might be unmaintainable if you never fully test it.

    Your code might be unmaintainable if your idea of testing it is getting your mate to check it out.

    Your code might be unmaintainable if you think SEO web development is the same as any other web development.

    Your code might be unmaintainable if it uses an exotic or obscure programming language.

    Your code might be unmaintainable if you set deadlines and tasks according to business preferences rather than resource availability.

    Your code might be unmaintainable if you're doing anything purely because it's what everyone else seems to be doing.

    Your code might be unmaintainable if you're more concerned with job security than what your job actually entails.

    Your code might be unmaintainable if you choose new technologies solely based on career aspirations and on what you think will be in demand in the future.

    Your code might be unmaintainable if you think being able to download, install and setup a matrix screensaver makes you a 1337 h4x0r.

    Your code might be unmaintainable if you think code should be beautiful and poetic.

    Your code might be unmaintainable if you wrote it with no design at all.

    Your code might be unmaintainable if you rushed it.

    Your code might be unmaintainable if the first thing you did when using a more language was to try to make it more like a language your were more familiar with than to learn the new language to the same extent.

    Your code might be unmaintainable if you need to comments on every other line.

    Your code might be unmaintainable if you can't find the entry point.

    Your code might be unmaintainable if it exits from several places and never returns from main.

    Your code might be unmaintainable if you use good practices by rote without understanding them.

    Your code might be unmaintainable if you copy and paste solutions without understanding them.

    Your code might be unmaintainable if you do anything without knowing exactly what you're doing.

    Your code might be unmaintainable if it's classed as enterprise.

    Your code might be unmaintainable if its benefactors have more money than sense.

    Your code might be unmaintainable if you fiddle with it until it works.

    Your code might be unmaintainable if you got it to work by a process of trial and error.

    Your code might be unmaintainable if an excerpt from it mysteriously appears on DailyWTF.

    Your code might be unmaintainable if you don't need to visit DailyWTF to find a WTF daily.

  • isthisunique (unregistered)

    Your code might by unmaintainable if you can't concentrate because the guy sitting opposite is speaking loudly and angrily on the phone in a foreign language for hours on end and he is the only one doing it in an office of hundred.

  • ImNotSaying (unregistered)

    Your code might be unmaintainable (by someone else) if you wrote it in assembly.

  • PWolff (nodebb)

    Your code might be unmaintainable if the CTO insists on being able to understand every single line of code. (Been there.)

    Your code might be unmaintainable if the devs pronounce 'backup' like 'bugup'.

    Your code might be unmaintainable if every developer thinks it is evident he/she is the sole genius and/or all fellow developers are morons. (Whether justified or not.)

    Your code might be unmaintainable if your boss believes that your hours cost the same no matter what you fill them with. E. g.: "Search for a free tool on the Internet, or hack up something." (Translation: "We won't pay 149.99 bucks for the best known product on market, no matter how sensible that might seem to you, and no matter what you think about the reliability of all other solutions.") (Been there.)

  • Steve_The_Cynic (nodebb) in reply to Paul Neumann

    Actually, my thought was "Statistical Quality Assurance"...

    But this is another example of an abbreviation repurposed for something else.

    Like SDLC. All these people today talking about Synchronous Data Link Control in contexts that are nothing to do with networking.

    Or CB. A bunch of people talking about Citizen's Band while NOT discussing unlicensed peer-to-peer vehicular radio systems.

  • PWolff (nodebb)

    Time for a rant. For reasons I just stumbled upon.

    ycmbui it accesses the Windows Registry.

    Big parts of it are sick. Just sick. (News at eleven, of course.)

    I'm not talking about storing integer values as REG_SZ. Or strings as REG_BINARY. That's just too common to be bothered anymore.

    I'm talking about [HKEY_CURRENT_USER\Control Panel\Desktop\WindowMetrics]'s keys ending with "Font".

    For example: Bytes 0x00 to 0x03 are the negative size in points, for a 72 dpi medium. Bytes 0x10 to 0x13 are the font weight (400 = standard, 700 = bold). Bytes 0x14 to 0x17 are 0 if normal and 1 if italic. Bytes 0x1C to the end are the name, coded in 16 bit integers.

Leave a comment on “Your Code Might Be Unmaintainable…”

Log In or post as a guest

Replying to comment #:

« Return to Article