Journal of number6 (1831)

Mypal - Pale Moon browser mod for Windows XP 32-bit

06:13 PM

""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" SEP 2017 "Mypal" Pale Moon browser latest build modified/patched to run on Windows XP 32-bit by Feodor2 INFO AND DL HERE.... https://github.com/Feodor2/Mypal/wiki PREVIEW LATEST RELEASE.... palemoon.exe -> Properties: FileVersion: 27.4.2.6451 BuildID: 20170830173929 PlatformVersion: 3.2.2.6451 Running -> Help -> About New Moon +-----------------------------------------------------------------------+ | About New Moon [X] | |-----------------------------------------------------------------------| | | | Version 27.4.2 (32-bit) | | New Moon unofficial version of Pale Moon released for | | windows xp. | | | | Therefore you may not ask any support from official Pale | | moon places like forum and so. | | | | There are no a webpage yet. | | | | Licensing information End-user rights Release notes | +-----------------------------------------------------------------------+ Running -> Help -> About New Moon -> click "Release notes" +-----------------------------------------------------------------------+ | Page not found - GitHub - New Moon [_][ ][X] | |-----------------------------------------------------------------------| | https://github.com/Feodor2/NewMoonXP/blob/master/README.md | |-----------------------------------------------------------------------| | | | 404 -- This is not the web page you are looking for | | | +-----------------------------------------------------------------------+ """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

Programming Lang of the future, Swift or Python....or BASIC

10:09 PM

"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" March 2017

#.........https://www.quora.com/Which-programming-language-is-going-to-be-the-language-of-future-Swift-or-Python
#.........Which programming language is going to be the language of the future? Swift or Python?
#.........
#.........Reply by Hanno Behrens, IT Consultant living in Germany
#.........Written 19 weeks ago

Most likely none of both. Both languages compete in a field of
binding-languages, which is a field of short living languages. Not that nobody
will program in those languages anymore in, say, five years, but they are both
under an incredible hype at the moment, which is more due to marketing issues
than that those languages are really that revolutionary and new.

See, Python and Swift both are trying to cover the field of application that is
known as "binding language". They are both so slow and memory hungry, that you
really don't want any serious application done in them. At least not beyond the
binding, the "scripting" of higher functions together.

Many things in bigger software projects have to be dealt with at client-side
and can not be pre-configured at compile-time. So that's why there are
scripting languages around like LUA for most gaming applications and even
JavaScript is such a language. It does serve the Browser-API, nothing more.

Said this, Python is a more general language than Swift, which is more or less
Apple-bound and does not find serious application beyond that platform at the
moment. As long as Apple is hyping it, it will live. But when Apple drops it,
it has no application whatsoever.

Python is indeed the new BASIC and fits into all applications that BASIC was
invented for. To be an easy comprehensible language. To be near English. To be
interactive. And more or less BASIC did what FORTRAN promised to do and where
ADA also failed.

But BASIC (http://gambaswiki.org/wiki/doc/benchmark?nh) is like 4 times faster
even than Pypy and like 30 times faster than usual Python or Python3. It's
delivered with an easy to understand IDE, it has community functions like
"click and post to community/share" and includes all system functions of the
operating system level that you want, which means it does everything Python
promises, but better, smaller, faster, cleaner and much more understandable.

Compiled Gambas is not much bigger than compiled C and if you ask me, that's
the next generation to go for all those Visual Basic programmers that had
enough off that shit. BASIC really is a cool language and yes, it is a
developing language. The stuff we did in the 80's isn't the stuff you are doing
today.

It's now structured, has objects and all modern concepts that you wish for. So,
from a clean neutral stand point, where I am, I would give BASIC more future
than any of those others. And I'm neutral, because I'm deep in C/ASM personally
and would not touch any of those languages with pliers. If I need a
binding/scripting language, I would use LUA for that. Because it's easy to
implement and import into every C or Assembly project, does play well with all
the other kids, isn't bloated and doesn't want to do everything.

It's just binding stuff and it's doing it fast and more efficient. Faster and
more efficient than any other language I know. Including Perl, which is a
language that competes on the same field and which is much better embedded into
systems than Python or Swift or whatever hog marketing drives through the
village will ever be.

Marketing interest in computer science were often a driving force to sell new
toolsets, to sell courses, to promote a "new better way to program" or other
bullshit (OOP, WYSIWYG, Big Data, Deep Learning,...). And it works in that way
as it is making a lot of money for those who ride that train. Object orientated
programming was one of those trains, that were ridden from the 90's up to day.
But the result is not what was promised. OO tend to end up in a bloody mess and
I don't want to go into depth here, what the reasons are for this. There are
paradigm-reasons and meta-reasons for that.

In short: teachers love OOP, engineers hate it. I'll skip the reasons.

Back to those two languages in question: as scripting languages they are on a
very shaky ground, with a high come and go rate. For quite a time Java seemed
to be dominant but with so much competition and so many changes it's
questionable if one of them will stay for long.

The basis of programming, the hard core is C and Assembly. Around this hard
core some minions gather and compete over the young programmers that are
learning and doing their first steps. Most of them will learn it, do it for two
or three years max, then fall away. A good language stays in mind over many
years and there are not many that will do this.

The only languages I have never forgotten were: ASM, C, BASIC, the ABC of
computing.

These languages have been in my portfolio for so many years and I neglected
some of them over 25 years or longer (BASIC for example), still: I can sit down
and write a program in BASIC like I did 40 years ago. Without even needing to
look up the manual. This language is easy. It totally holds what it promises.

Python? I forget the typical FOR...NEXT construction after two months not
programming that stuff. And I did commercial works in Python, so I did work in
that for quite a time. Still, it's lousy to memorize.

The others never will leave you, once you learned them. Never. And this is the
point of survival and death. In ten years, when the hypes are over, those
languages that don't stick will go away again.

Those languages that are keepers, will stay. And people learn over all their
life, they accumulate knowledge and usually can do much more productive and
revolutionary programs with 40 than they were able to do with 20.

I don't give personally a shit about all those scripting languages and which of
them will survive. For me they are just a filling tool for the real programs to
show some flexibility on the clients computer without needing to install a
whole development environment and recompile the whole thing, just because you
want to change one small parameter.

And for that LUA is the perfect solution.

For the kids wanting quick fun with their Raspi or little computer and without
much knowledge about hardware but with the ability to do all their hardware
can. With a maximum of performance, with a child-level easy language, that's
BASIC. It was BASIC, it will always be BASIC. And this is true for the
construction engineer who is not a programmer but just wants to calculate some
formulas or the technical expert in medicine, in sociology, in physics and
other fields, where it is not important to do huge number crunching and
efficiency, but to just give a result: BASIC.

FORTRAN is dead, not because of C. FORTRAN is dead because of BASIC. It does
the same thing but much much better and easier. With the same philosophy behind
it, but very much better executed.

And it does most things Python promises better. So, after all this hype is
gone, BASIC will still be there. Can't say it's my language, but I can see what
it promises and that it does, indeed, deliver. Just try to do a graphical plot
in Python. Then look at BASIC. Yeah. It's included.

And it's like 30 times faster. So, I really don't think Python or Swift will
make it. But people really have to come down from their high horse and wave
away that language: it's a deliverer. It really does what others only promise.
It's a keeper. It's small and effective. It is type-safe. It can be compiled
without a problem.

It will be there when Python and Swift have long gone the way of ADA or FORTRAN
or REXX (loved that!) or LISP or FORTH (I really love Forth!) but they are
gone. They won't come back.

We have better tools for all that, now. Maybe, just maybe, Python survives in
the niche that was left by LISP. Can be. But I don't trust programmers that
think that recursion and lambda calculus are the solution for everything. I
just see the very lame performance of it and it is indeed very lame. And it is
not "easy to understand", it's a highly abstracted way to solve problems. Not
very like the way humans think, no the way our machines work.

So, they are fascinating, I give you that, but I don't want them in any
productive system. They are for schools.

"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

Firefox Keyboard Shortcuts - textfile

07:59 PM

Programming Languages: Genealogy and Beginner's Guide (1985)

02:48 PM

---------------------------------------------------------------------------------------------- ********************************************** Programming Languages: Genealogy and Beginner's Guide by Les Bell (1985) ********************************************** No matter how much you pound on the keyboard and curse the inventor of microprocessors, there is only one way to get a computer to do what you want, and that's to program it. You give it its directions and turn it loose, and hopefully you will be pleased with the result. The trouble is that, advertising to the contrary notwithstanding, microcomputers are not smart enough to understand simple English, even of the kind used to communicate with under-tens: "Tie your coat up or you'll freeze", or "Don't do that or I'll thump you". Being a bit deficient in the brains department, computers force us to make some accommodations in their favour, so we must communicate with them in their particular languages, in much the same way as one does not throw the jargon of quantum mechanics into a conversation with a five-year-old. Computer languages are generally organised to be a sub-set of conventional English (although I once encountered an IBM 5100 which spoke BASIC with a French accent), so there are no new words to be learnt and the coding is not too mind-boggling. Although English is a general-purpose language, most computer languages are designed to solve specific classes of problems. For example, COBOL is designed specifically for commercial accounting applications, while LISP is primarily a list processing language with strong ties to artificial intelligence applications. ====== THE GENEALOGY OF LANGUAGES Take a look at the languages family tree (Figure below), and you'll get some idea of the development of computer languages and how later developments derive from the earlier ones. At the root of the tree is assembly language, or assembler, which is a symbolic representation of the instructions actually executed by the computer CPU. There are, therefore, as many assembly languages as there are CPU designs. The languages family tree shows how today's high-level languages "grew" out of Assembler, which is just a symbolic representation of the instructions actually executed by the computer's CPU. Since Assembler is somewhat tedious to write, many attempts have been made, working from different requirements, to create languages based on English yet structured efficiently for the computer. ============================================================================================== (LOGO) | | (C) (Smalltalk) (Prolog) | \ | | \--------\ | | \ | (B) (Clascal) (Modula II) (Ada) (Data base langs) (PL/I Subset G) (PL/M) (LISP) \ \ | / | \ | / / \-----\ \---\ | /----/ | \----\ | /--------/ / \ \ | / | \ | / /------------------------/ \ \ | / | \ | / / (FORTH) (BCPL) (Pascal) (ALGOL 68) (PL/I) (APL) (BASIC) (PILOT) \ | / / | \ \ / / \---\ | /----/ / | \ \ / / \ | / /-------------/ | \---\ \ / /-----/ \ | / / | \ \ / / (ALGOL 60) (COBOL) (FORTRAN) | | (AUTOCODER) | | (Assembler) - Figure: Languages family tree - ============================================================================================== Each line of assembly language is translated into one machine instruction. It follows from this that writing assembly language is a tedious and unproductive chore, since even the simplest tasks may require several hundred lines of Assembler. During the [1950s], programmers at IBM realised this and set about designing a better way of writing computer programs. Since operations like addition were always performed the same way, they thought it would be possible to get the machine itself to translate a line like X = X + 1 into the appropriate assembly language code. Indeed, it was possible, and the result was Autocoder, which was thought of at the time less as a Language than as a way of pre-coding instructions. Autocoder is now of historical interest; its main contribution was in supplying technology and experience to FORTRAN, which is generally regarded as the first real computer language. FORTRAN (which stands for FORmula TRANslator) was developed at IBM by John Backus. At the time, computers were mainly used for number-crunching in scientific calculations or for very large commercial accounting tasks, and FORTRAN was designed to meet the needs of the scientific and engineering community. FORTRAN still survives today; it's probably more popular than ever. Of course, it has been overhauled a few times since 1960, and the well-written programs coded in the latest FORTRAN-77 bear only passing resemblance to their earliest counterparts. At the same time, the US Department of Defence was increasingly using computers for tasks like payroll accounting and quartermaster's inventories, and the specialists at DOD were concerned that every computer they bought came with its own language. As programmers went from project to project and machine to machine, they had to learn new languages. The search was on to design a new language. The result was COBOL (Commercial and Business Oriented Language), which has become the standard for business data processing. The key designer behind it was Grace Murray Hopper, who as Commodore Hopper is the US Navy's most senior woman officer and its oldest serving officer, despite trying to retire several times. COBOL is a wordy language, but even novice programmers picking up a COBOL program can read it and quickly understand it, because of its self-explanatory nature. For example, where FORTRAN would say O = G - T COBOL would have SUBTRACT TAX FROM GROSS-PAY GIVING NETT-PAY which is less cryptic. At the same time, on the other side of the Atlantic, the Europeans were also hard at work, and a committee of leading academics and representatives of leading computer manufacturers like Elliot and Ferranti was meeting to design a new language. This language was intended to be used for the expression of any algorithm -- that is, any set of steps which lead to the solution of a problem. Its genesis was therefore more mathematical than pragmatic, as witnessed by the fact that the language has no input/output statements, while most real-world programs actually spend most of their time doing input/output. The language was Algol (ALGOrithmic Language) and while it became popular in Europe, it never really caught on in the US. That's not to say that US programmers did not see its advantages; within a few years they were happily incorporating its structured programming techniques into new languages of their own. By 1961, it became obvious that programmers were having to learn one language for commercial programming, another for scientific programming and yet another for general work like writing compilers. There had to be some way of writing a language which would incorporate the best features of all languages, allowing programmers to use just that language for all projects they worked on. IBM, together with the two IBM user groups, SHARE/GUIDE, set out to tackle this problem, and came up with the answer: PL-I (Programming Language/One). With features borrowed from FORTRAN, COBOL and Algol, plus more than a few of its own, PL/I proved to be too big a language for any mortal to possibly remember. Nonetheless, it is still popular inside IBM, and stripped-down versions are catching on with minicomputer and microcomputer companies. Another language emerged from IBM in the mid-Sixties, which captured a specialised following. APL (A Programming Language) was designed by Ken Iverson for time-shared number-crunching tasks, particularly those involving manipulation of arrays and lists of data. Rather than using English words, APL has its own character set, which makes it look rather intimidating, and its unusual syntax can be mind-boggling to those raised on more conventional languages. It makes firm converts, though. Also developed in the mid-Sixties, and designed for timeshared use, was another language which has swept the world -- well, the microcomputer part of it, at least. BASIC (Beginner's All-purpose Symbolic Instruction Code) was invented by Kemeny and Kurtz at Dartmouth College, for the use of engineering and other students who needed an introduction to programming for the solution of small problems which did not justify mastering the complexities of FORTRAN FORMAT statements. BASIC inherits a lot of its design from FORTRAN, without some of that language's complexities -- at its simplest level it is really just FORTRAN with the addition of line numbers. Over the years, however, BASIC has gradually been extended and given more power, with the addition of new statements, new functions and features such as graphics. There is, in fact, some merit to the argument that BASIC has gone the way of PL/I and the later Algol 68: it is too big for anyone to remember all of it, certainly in casual use. In the late Sixties, the Algol Committee met again to update Algol. Wishing to correct for the over-simplistic (nonetheless powerful) nature of the earlier version, this time they threw in not only I/O statements but everything else they could think of, rather like PL/I. The result was Algol 68, a massive language with special statements for every circumstance. While Algol 68 never really caught on, it is of vital importance to the micro community in one sense: one member of the Algol Committee consistently argued against the construction of a huge language, and in favour of a small but well-structured and consistent language that could be used to reproduce the special features of Algol 68. Incensed at the elephantine creation of the committee, this member determined to prove his point by writing his [own] language. The man was Niklaus Wirth, the language was Pascal. Firmly based in Algol, with only a few carefully-chosen features of its own, Pascal has proved to be a remarkably expressive language, suffering only from deficiencies in the I/O and system manipulation areas, most of them inherited from Algol. Pascal added a number of important concepts to the computer linguist's arsenal, but the most important of these was the idea that the compiler should catch as many errors as possible before the program is actually run. The result of this philosophy is a language that many find overrestricting: Marvin Minsky of MIT refers to Pascal as "a voluntarily worn strait-jacket". While Pascal has now fallen out of favour, it has made a contribution to a number of other languages. Wirth himself has dropped Pascal and developed a further language called Modula II, which extends his concepts. In the early Seventies, researchers at Bell Laboratories developed a couple of languages which have now come to a position of great influence. Based on the BCPL language developed at Cambridge University, B was a small language which could be used at a low level as a replacement for assembly language. Its successor, C, is a general-purpose language with the potential to replace FORTRAN and Pascal. Just as Pascal was a reaction against another language, so is C. PL/I was used to write a large operating system called MULTICS, but at Bell Labs work was under way on a stripped-down operating system called UNIX. C was developed in the same spirit, as a stripped-down language that could be used in the implementation of the operating system, its compilers and utilities. The leanness of both UNIX and C reflect the small group of developers: Thompson, Kernighan and Ritchie. Algol 68 is important in another way: as a precursor of a new language called Ada. Ada, Countess Lovelace (Byron's daughter) was an associate of Charles Babbage, inventor of the analytical engine, and is generally credited with writing the first computer program, in the 1830s. She is celebrated in the name of the US Department of Defence's new language. Ada follows in the footsteps of Algol 68 and PL/I as a large language, but it has a rather more modern style and a number of new twists of its own, particularly in the areas of modular programming and inter-process communication (multiple programs communicating with each other). Two other outgrowths of PL/I are important in the microprocessor world: PL/I Subset G and PL/M. PL/M was in fact the first high-level language to run on a micro-processor; it was developed by Dr Gary Kildall for Intel Corp. While it is a cut-down derivative of PL/I, specifically designed for microprocessor applications such as traffic light controllers, it is sufficiently powerful to allow construction of software tools such as the CP/M operating system, and the CBASIC compiler which was used to write some of the first commercial software for micros. Without PL/M, micros might never have got off the ground. PL/I Subset G is the minicomputer subset (ANSI X3J1) of the mainframe PL/I. A lot of dead wood has been cleared away, and what is left is a language remarkably like Pascal, but with none of the silly restrictions and with enough special facilities for real-world programming — like formatted I/O for commercial programming and double-precision hyperbolic functions for the scientists. Also shown as derived from PL/I is a general box of database languages. This perhaps is not a direct derivation, but more of a philosophical contribution. Most special-purpose database languages require COBOL-like (hence PL/l-like) report formatting and string handling, coupled with modern control structures derived from Algol, via PL/I. Examples range from IBM's DL/I to dBase II. ====== ORPHANS? While these languages have a well-defined place in the family tree, there are a number of other machine tongues which have no obvious ancestry. FORTH, for example, was developed by astronomer Dr Charles Moore for use in radio-telescope research. It bears little relation to earlier languages in either its internal operation or its external appearance. A FORTH system starts with a dictionary of approximately 140 elementary words, and the user proceeds to define new words in terms of the old ones. At the top level, words are entire programs. Like APL, FORTH can be mind-boggling to the initiate, but breeds converts stronger than any other religions. Smalltalk has been developed over many years at Xerox's Palo Alto Research Center (XPARC), as part of the long-term Dynabook project. In Smalltalk, objects are collections of apparently concurrently executing subroutines, and are controlled by sending messages to them; for example BOX GROW 5 sends a message to BOX, instructing it to run its internal subroutine GROW (called a method) with the parameter 5. The likely effect of this is that a box on the screen will grow in size by five units. Related to Smalltalk is Logo, which was developed at MIT by Seymour Papert. Logo is best known for its turtle graphics, which use an imaginary turtle on the screen to draw shapes. PILOT is another language developed for educational applications, by Dr John Starkweather. It is a simple language primarily intended for drill and testing. LISP (LISt Processing language) is an unusual language which views all data as lists of items. It is very simple, yet very powerful, and has attracted attention in the artificial intelligence community because LISP programs are simply lists of items and can therefore modify themselves. LISP is also known as Lots of Insane Stupid Parentheses because of its extensive use of brackets. PROLOG is a logic manipulation language which is distantly related to LISP. It can maintain a database of data items and rules relating them, and can then answer questions about its database. Currently PROLOG programmers are in great demand in Japan, where it is a cornerstone of the Fifth Generation artificial intelligence project. PROLOG (PROgramming in LOGic) is based on first-order predicate logic. The program starts with a statement which is to be proved, and continues with propositions which will be used to assert the truth or falsehood of the goal statement. It looks very strange to newcomers, but I guess we'd all better get used to it. ====== WHERE TO USE WHICH LANGUAGE With so many languages to choose from, how do you decide in which circumstances to use each? The answer is not simple, and beyond a certain level it becomes a matter of personal taste. For general messing about, trying out ideas and knocking together 'quick and dirty' programs the best language is generally BASIC. The major reason for this is that it is so prevalent: every small micro offers BASIC as standard. A micro programmer who does not know BASIC is not much use, really. You can do just about everything you are ever likely to need in BASIC, with the assistance of some assembly language patches for some things like getting at special I/O ports and the like. There are only two problems: there is a diminishing rate of return in using BASIC for large programs, and the resulting program is generally slow. The second problem can be fixed, to some extent, by using a compiler on the finished program. But the first is more fundamental and is related to the lack of support for good structured programming practices within the language. Some versions, such as CBASIC Compiler and Waterloo BASIC, provide support for local variables, named subroutines and the like, but this poses the question: are such languages still BASIC or are they something new and different? Well-written CBASIC code, for example, looks more like Pascal than BASIC. If we use cars as an analogy for languages, then BASIC is the family sedan. It's inexpensive, there are lots of models in the range, and the most popular models have all kinds of (previously optional) extras fitted as standard. Ah yes, Pascal. I only ever wrote one major package in Pascal, and would never use it again if I could avoid it. Pascal is okay for academia, where all the people who will use a program are computer literate, familiar with the operating system, and so on. But in the real world, programs get used by office juniors, managing directors and other people who are completely fazed by error messages and who are liable to type the most improbable input string imaginable. Real-world programs, therefore, have to have extensive input validation, and this turns out to be quite difficult in Pascal, as it is tediously unco-operative in type conversions. The Pascal programmer has thus to resort to all kinds of devious practices to get Pascal to work for him, which defeats the purpose of using the language in the first place. If you have to use sleight of hand so that the compiler can't understand what you're doing, there's a fair chance you can't understand it yourself. The right place for Pascal, then, is where you have to write programs of moderate sophistication which you will only ever use yourself, and where you are sure that a straight solution will do. I know this is cruel and a bit over the top, but the best analogy I can find for Pascal is a trainer bicycle. You can't go far with it, you can't go fast with it, you can't carry much with it, it's not to everybody's taste, but at least you can't fall over while riding it. FORTRAN lives on in the scientific world; first of all because most engineers and scientists cut their teeth on it, so it is widely known. Second, it is one of the first languages every mainframe and mini manufacturer provides on their machines, so programs originally written on larger computers can be transported to micros and vice versa. The fact that it is well-standardised assists this. A third factor is the vast amount of FORTRAN software which has been published or placed in the public domain for all kinds of purposes. The sheer inertia of the FORTRAN movement ensures it will be around for a long time, and a FORTRAN compiler is a must for every micro in a scientific or engineering lab. However, that's not to say FORTRAN is always the best tool for the job. Pascal can be appropriate here for simple jobs, or PL/I (with its superb double-precision arithmetic and hyperbolic functions) for the more complex ones. C is also an appropriate tool on occasions. However, those who own FORTRAN compilers should bear in mind that Real Programmers use FORTRAN. FORTRAN is a bit like a Volkswagen Beetle; the design hasn't changed much over the years, and people wouldn't like it so much if it had. It's a very rational and appropriate design, with few concessions to style or fashion. COBOL finds its metier in the commercial world where programs have long lives and may be worked on by as many as ten programmers during that time. Consequently, the requirement is not for flash, tricky code, but for code that your average commercial programmer can pick up, understand and modify or fix. While the previous generation of COBOL compilers acquired a reputation for being as slow as a wet weekend, the latest releases are much improved, making COBOL a viable alternative for the commercial micro user or software house. COBOL is like a half-ton truck: it serves the needs of commerce with little style. It can carry quite heavy loads, but will never turn heads as it passes. PL/I -- ah, now here's a language for Real Programmers. I turned to PL/I after my nasty experience with Pascal and have never regretted it. Block structures and structured programming statements like Pascal's, combined with sophisticated file handling and I/O, and the ability to do binary arithmetic for scientific applications and decimal arithmetic for dollars and cents, mean this is a language one can stick with. While the rest of the world follows fashions like Pascal and C, we PL/I programmers will be quietly getting on with the job. If you're a COBOL programmer who wants to have some good structured programming support and less verbose code, PL/I may be for you. If you're a FORTRAN programmer who wants higher precision arithmetic, better string handling and structured programming support, PL/I is it. If you're a Pascal programmer who feels the need for the occasional goto -- used with discretion, of course -- as well as sensible file handling, check out PL/I. If you're a C programmer, nothing I say is going to change your mind anyway; but PL/I has pointers, structures, unions, functions, storage classes and all the other things that make C such fun. PL/I therefore emerges as a good all-round language with particular strengths for commercial software and scientific applications, though utilities compiled in it tend to be a bit large. It's a little like these new family vans with seats that fold, turn and twist: you can use it as a sedan, as a minibus, as a delivery van or as a camper. Bear in mind that, unlike those vans, it has a V12 under the bonnet. C is a sports car in comparison. It's small, zippy and manoeuvrable, very light in weight, and when it crashes you're a gonner (due to the lack of run-time debugging facilities, you see). C is best used to write systems utilities such as archivers, macro processors, editors, compilers and the like. It can be used to write commercial or scientific programs, though its arithmetic and file handling let it down in the former area. If you build on its lower-level functions to construct nice string-handling and I/O functions, what you wind up with is very like PL/I, which would have made a more appropriate starting point. The best feature of C is its portability. C programs can generally be moved from system to system with a minimum of effort, and this means that software authors can be assured of achieving the maximum return for their effort. PROLOG is quite different from most languages. At the moment it's still barely out of the research labs, and most users are in universities. I dare say PROLOG could be put to commercial use, particularly in bibliographic databases, small 'expert' systems and the like. In the car metaphor, PROLOG is rather like those experimental designs manufacturers roll out every now and again, informing us that in ten years time we'll all be driving cars like these, with four-wheel steering and the like. Ada is an armoured personnel carrier. It's designed to be reliable, carry all kinds of loads, be fast, and it has a radio built in so it can communicate with other carriers. Ada directly supports a number of recent structured programming concepts. For example, the idea of separate compilation of modules has been around for a long time; many Pascal, C and PL/I compilers offer this facility. But Ada is the only language to date to support the separate compilation of modules (Ada calls them packages), as part of the language. An Ada package comprises two parts -- a specification part and an implementation part. Each is a unit (this will sound familiar to UCSD Pascal users) and can be separately compiled. Parts of a package specification can be made invisible, so users of a package can only deal with the logical interface of the package; other details are hidden. Ada directly supports multi-tasking -- that is, the ability to run several different program streams at the same time. A lot of thought has gone into the language's design, to ensure that Ada programs are less expensive to maintain, and are more reliable, than those in older languages. Ada is about the only thing that could tempt me away from PL/I ... /---------------------------------------\ | Copyright (C) Les Bell | | source: "Your Computer, January 1985" | \---------------------------------------/ ----------------------------------------------------------------------------------------------

How security issues happen in Windows OS code - ReactOS blog

12:58 AM

//BOF ## <https://www.reactos.org/node/932> ## ReactOS Project Home -- Blogs -- ThFabba's blog ## How do security issues happen? ## by `ThFabba` -- 11 Feb 2015 If you are a Windows user, you may be used to seeing a bunch of updates pop up around the second Tuesday of every month that purport to fix "critical security issues." Microsoft's continuous effort to fix these vulnerabilities in its operating system consumes a lot of resources, but it is well worth it to the users: in a world of ever-increasing cyber security threats, no hole in our computers' defenses should be left open to potential attackers. The recent mailing list discussion around ReactOS SVN revision 66192 <https://www.reactos.org/pipermail/ros-dev/2015-February/017103.html> shows just how easy it is to introduce a critical security issue into kernel code. I will be using this instance as an example of a simple but security- relevant bug, and to illustrate some of the steps kernel code must take to ensure the security of the system it runs on. SPOTTING THE VULNERABILITY So let's get right on it and have a look at the code in question: *********************************************************[code block 1 begin] NTSTATUS APIENTRY NtUserSetInformationThread(IN HANDLE ThreadHandle, IN USERTHREADINFOCLASS ThreadInformationClass, IN PVOID ThreadInformation, IN ULONG ThreadInformationLength) { [...] switch (ThreadInformationClass) { case UserThreadInitiateShutdown: { ERR("Shutdown initiated\n"); if (ThreadInformationLength != sizeof(ULONG)) { Status = STATUS_INFO_LENGTH_MISMATCH; break; } Status = UserInitiateShutdown(Thread, (PULONG)ThreadInformation); break; } [...] } ***********************************************************[code block 1 end] The above is a snippet from NtUserSetInformationThread, which is a system call routine in win32k.sys that can be (more or less) directly called from a user-mode program. ThreadInformation is a pointer to some arbitrary piece of data whose meaning depends on the ThreadInformationClass parameter. In the UserThreadInitiateShutdown case, it is supposed to be a single 4-byte integer. ThreadInformationLength describes the size of this data, and as we can see, the code validates that this value is correct and fails with STATUS_INFO_LENGTH_MISMATCH if it is not. Note that both these parameters come directly from the user program, so a piece of malware calling this function would have direct control over their values. Now let's look at what happens with ThreadInformation as it gets passed to UserInitiateShutdown: *********************************************************[code block 2 begin] NTSTATUS UserInitiateShutdown(IN PETHREAD Thread, IN OUT PULONG pFlags) { NTSTATUS Status; ULONG Flags = *pFlags; [...] *pFlags = Flags; [...] /* If the caller is not Winlogon, do some security checks */ if (PsGetThreadProcessId(Thread) != gpidLogon) { // FIXME: Play again with flags... *pFlags = Flags; [...] } [...] *pFlags = Flags; return STATUS_SUCCESS; } ***********************************************************[code block 2 end] Because large parts of this function are unimplemented, all that happens is that the 4 byte value the user pointed us to gets read, and then written back unmodified a number of times. SO WHAT'S THE PROBLEM, YOU ASK? Well, the act of dereferencing an unchecked pointer alone is enough to allow a denial-of-service (DoS) attack -- a malicious program could simply shut down the system without acquiring any permission to do so. As an easy example, a program could just pass in a NULL pointer to exploit this vulnerability. This would cause UserInitiateShutdown to dereference said pointer, which would result in an instance of the infamous Blue Screen of Death, usually referred to as a "bug check" by kernel programmers. In this case the calling user even has an opportunity to write to memory, though (and remember that this is an arbitrary pointer -- it can even point to kernel memory!). While writing back the same value that was previously read from this memory location may not seem too bad at first glance, it is actually quite problematic. Some memory locations change frequently, and restoring a previous value found at such a location may for example compromise the quality of entropy used for cryptographic random number generation; or you may choose to restore an old page table mapping that should have been deleted, allowing you access to more memory that may be used to compromise the system. However these are just examples I came up with within a few minutes; determined attackers may have months to figure out the best way to achieve their goals, so a seemingly small vulnerability like this may well be enough for them to steal all your secrets and gain complete control over your machine. Finally of course, if the function was fully implemented, it would actually change the Flags variable prior to writing it back, offering up the option to modify arbitrary (kernel) memory in a controlled way -- a feast for any attacker. KNOWING ALL THIS, HOW DO WE FIX IT? To protect against this kind of problem, the NT kernel offers two mechanisms: Probing, and Structured Exception Handling (SEH). Probing the memory fixes a large part of the problem: it ensures that the pointer we receive from the user program actually points to a user-mode address. Performing this check on all pointer parameters ensures that user-mode software does not get access to kernel-mode memory in this way. However this does not protect us from simply receiving a NULL or other invalid pointer. This is where the second technique, SEH, comes in: wrapping every access to data through a user-provided (and thus untrusted) pointer in an exception handling block ensures that the code retains control even if this pointer is invalid. The kernel-mode code provides an exception handler for this case, which gets called whenever the protected piece of code raises an exception (such as an access violation due to the use of an invalid pointer). The exception handler collects available information (such as an exception code), performs any necessary clean-up and usually simply returns to the user with a failure code. Let's have a look at the fixed code as of( <https://code.reactos.org/changelog/reactos?cs=66223>): *********************************************************[code block 3 begin] ULONG CapturedFlags = 0; ERR("Shutdown initiated\n"); if (ThreadInformationLength != sizeof(ULONG)) { Status = STATUS_INFO_LENGTH_MISMATCH; break; } /* Capture the caller value */ Status = STATUS_SUCCESS; _SEH2_TRY { ProbeForWrite(ThreadInformation, sizeof(CapturedFlags), sizeof(PVOID)); CapturedFlags = *(PULONG)ThreadInformation; } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { Status = _SEH2_GetExceptionCode(); } _SEH2_END; if (NT_SUCCESS(Status)) Status = UserInitiateShutdown(Thread, &CapturedFlags); /* Return the modified value to the caller */ _SEH2_TRY { *(PULONG)ThreadInformation = CapturedFlags; } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { Status = _SEH2_GetExceptionCode(); } _SEH2_END; ***********************************************************[code block 3 end] Notice that all accesses to the untrusted ThreadInformation pointer are now performed inside _SEH2_TRY blocks. Exceptions occurring inside these blocks will be handled in a controlled manner by the code in the _SEH2_EXCEPT block. Additionally, ProbeForWrite is called before the pointer is dereferenced for the first time; this will raise a STATUS_ACCESS_VIOLATION or STATUS_DATATYPE_MISALIGNMENT exception if it detects an invalid (e.g. kernel-mode) pointer or non-writable memory. Finally, note the use of a "CapturedFlags" variable that's being passed to UserInitiateShutdown. This is a trick that simplifies handling of the untrusted pointer: instead of having to use SEH every single time pFlags is accessed inside the function, the value is saved to a trusted location by NtUserSetInformationThread, and written back to user memory after UserInitiateShutdown returns. This way, there is no need to modify UserInitiateShutdown itself, since its argument is now a trusted kernel-mode pointer (to CapturedFlags). As a result of applying these measures, this case of the function can now handle arbitrary valid or invalid user input without adverse effects on the system. Mission accomplished! WHAT SHOULD WE LEARN FROM THIS? As we've seen, with a watchful eye early on in development, it is possible to spot code that may prove to be a severe security issue later on. We can't afford to have too many of those, because to be honest, you can be sure we'll have enough security problems anyway -- in fact, if all goes well, we'll go hunting after them in the future, and providing regular fixes just like you see in Windows Update every month. As an interesting side note, Alex Ionescu pointed out that Windows has been shown to have a vulnerability in the very same function, NtUserSetInformationThread. According to Alex Ionescu, this one is still unfixed, and is used for example to jailbreak devices such as the Surface RT. It was described in 2012 by well-known security researcher Mateusz "j00ru" Jurczyk (who likes to hang out in our IRC channel, too ;]). You can find his blog entry on this subject at( <http://j00ru.vexillium.org/?p=1393>) DISCUSSION: <https://reactos.org/forum/viewtopic.php?f=2&t=13999> /--------------------------------------------------\ | This blog post represents the personal opinion | | of the author and is not representative of the | | position of the ReactOS Project. | \--------------------------------------------------/ //EOF

Vopt (defrag program) turns freeware after author's death

11:05 PM

Vopt (pronounced 'vee-opt') is a commercial disk defragmentation utility for
the Windows platform which was first released in the early 1980s. It has
supported all versions of Microsoft Windows ever released, including MS-DOS!

Its author, Howard Barry Emerson, passed away on Feb 2016 at the age of 75.

Emerson declared in his will that Vopt should become available for all users
in the event of his death. As per his will, Vopt is now offered as a free
download at its homepage. There you will find listed the registration file for
the program which you can copy to the program installation folder on Windows
to make it fully functional.

Vopt homepage: http://www.vopt.com/index.html

=============================================================================

A farewell tune to Mr. Emerson from me ...cheers and thanks for the memories:

Gerry & The Pacemakers - You'll Never Walk Alone
<http://www.youtube.com/watch?v=ctbNzW9gc_A>

=============================================================================

A text file from my computer archives:

Best Windows 7 Defrag App -- Windows 7 Forums [June 2010]
<http://www.sevenforums.com/software/92295-best-windows-7-defrag-app.html>

There is always a lot of controversy when it comes to disk defragmentation
tools. Some people believe that you do not need a third-party disk
defragmentation tool. Others are loyal to a specific program. Well, here's my
thoughts. I will even tell you why.

I know that a lot of you are huge fans of free programs but this is one case
in which I would recommend making an exception...

For regular 'home' users all defragmenters do the same good job... with one
exception: Vopt is the only one capable of optimizing start-up files
INCLUDING realigning the pagefile. To do this the right way, a little bit of
thinking is required.

Some say the size of your pagefile is depending on your installed RAM. Wrong.
It depends on your daily work. For example:

The "commit charge" of Designers working with Photoshop day in day out
is WAY higher than for the average guy who plays some games - no matter how
much RAM is installed.

To find your "personal" pagefile size, use the computer as you normally would.
After a few hours, open your Task Manager (CTRL-ALT-DEL) and go to the
Performance tab and check the "commit charge"

Performance
Total: RAM currently used
Limit: Physical RAM + current pagefile
Peak: Most RAM used today (well... peak)

As you can see, the difference is quite noticeable. You can reduce the size of
your pagefile. Smaller pagefile = better performance.

Now press Win+Pause -> Advanced tab -> Performance -> Click Settings
-> Advanced tab -> Virtual Memory -> "Change"

By default "System managed size" is checked. Now Windows
tends to increase and decrease the filesize whenever it's bored, causing your
pagefile to split into fragments which then causes performance loss.

To optimize this, check "Custom size" and lock the file by entering YOUR
personal value TWICE. Don't forget to click on "Set" afterward. Nowadays a
value of 512MB is just fine. Don't go lower.

If you have, for example, 1GB of physical RAM and your "Peak" was 695MB
(729,000 KB) set it to 512MB or 768MB

Windows will ask you to reboot your computer once you accept all changes;
Do it.

Finally, run Vopt and run the Clean Tasks first to get rid of junk files.
Select the Drive with your new pagefile (usually drive letter C),
click "Defragmenting" -> "Defrag pagefile"

The clever method - and Vopt is the ONLY one who does it:
Vopt moves the complete pagefile to the very middle of your HDD. Why? Because
the middle or the center is the Idle-point for the HDD's shuttle. This ensures
the LOWEST access time possible.

Furthermore, Vopt overrides loading AutoStart and some Core Applications
during the next boot. Otherwise you couldn't access and/or move them. Sounds
logical, right? I thought so too

This procedure is what I've been doing FIRST on a fresh system for the past 8
years.

Destroy Windows 10 Spying (portable app by a Russian hacker)

02:54 PM

I notice a lot of heat being generated about privacy concerns and the uncontrollable features in Windows 10.
So let's "control" it . . . . .

______________________________________________________________________________

Here is a program:

Destroy Windows 10 Spying
(C) Nummer
This is a portable app that can block anonymous data being sent and remove apps that can't be removed the standard way.
It can remove Windows default programs that can't be removed under Apps & Features and more.
OPTIONS:
/win=destroyspy - execute disable spyware in Win10 in the hidden mode.
+removeapps - setting for the last argument. Not required. When you clean up removes Windows 10 application.
/win=cleanhost - run the program in stealth mode, and clean the hosts file.
/msbox=false - disable pop-up windows while the program.
/uac=disable - Disable UAC
/uac=enable - Enable UAC
/removeapps=all - !!! DELETE ALL METRO APPLICATIONS !!!
/explorer=default - When you start the Explorer, open the "This computer"
-spydomaintohosts - not in the hosts file to add spyware domains.
-disabletasks - do not disable spyware task scheduler.
-defaultphotov - not set image viewer Windows as a standard.
-disableprivatesettings - do not disable private settings.
-disablekeylogger - do not remove the keylogger.
/windowsupdate=on - turn on Windows Update
/windowsupdate=off - turn off Windows Update
Arguments can be combined. Example:
"C:\DestroyWindowsSpying\bin\Release\DestroyWindowsSpying.exe" /win=destroyspy +removeapps -defaultphotov /msbox=false
This command we execute cleaning up spyware, together with the removal of Windows 10 applications, but will not be used as a standard photo viewer.
!!!! ATTENTION! OPERATION delete all METRO APPLICATIONS irreversibility !!!!!
How to recover Windows Store http://winaero.com/blog/how-to-restore-windows-store-in-windows-10-after-removing-it-with-powershell/
HISTORY:
version 1.4.3:
* Fix BUGS
+ Full customization of the program.
+ Full disabling Windows Defender
+ Added shutdown utility updates Windows
* Now when cleaning up hosts file, the program makes a backup. It is stored in System32/drivers/etc/hosts.bak
- Removed domains of Skype hosts. YOU ARE USING SKYPE IS AT YOUR OWN RISK! ALL YOUR MESSAGES FROM MICROSOFT Skype will be at!
+ Added button surprise (just kidding).
* Added task to disable the Office 2016 espionage.
v1.4
* Fixed a bug, when added to the hosts of the same Domenti
* Changed the GUI
* XBoX now completely removed.
* The algorithm off jobs in the scheduler (now faster)
+ Added address to hosts
* Changed the principle of removing keylogger (deletes Now 100%)
* Using Edge and Windows Store without problems. They do not send data to the server M $ (they are added to the hosts)
* Now Windows Update does not send all the data on your computer, and sends only necessary to download updates.
version 1.3
* Fixed the bug of adding hosts in Windows 10 Home
* Fixed bugs work on x86 systems
+ Added Russian language
+ Added selection of applications that should be removed
* Fixes errors
* Other algorithms remove keyloggers.
version 1.0
* The program disables the task keylogger in Windows 10.
* In addition, it adds all the services of reception reports M$ to hosts file + disables advertising in Skype it.
* It removes the (optional) application on Windows 10 who are prevented many
* I think this can be completed. About bugs evading the topic, and putting a log.
LINKS:
.
Program Developer (Nummer @nummerok) - his Twitter Page:
https://twitter.com/nummerok
.
Program Discussion Thread (in Russian, copy-paste text into Google Translate for English):
http://rutracker.org/forum/viewtopic.php?t=5054236
.
Program Sourcecode text pasted on online:
http://pastebin.com/UfzVWKum
.
Discussion about Win10 spying features (in Russian, copy-paste text into Google Translate for English):
http://rutracker.org/forum/viewtopic.php?t=5054096
.
Direct download v1.43 from a file-hosting service:
http://www.mediafire.com/download/ktdybvma28j38q2/DWS.zip
(10.32 MB)
(ZIP file contents: about_destroy_windows_spying.nfo | DestroyWindowsSpying.exe | readme_en.txt | readme_ru.txt)
(Note: I don't expect the DL link to last forever so grab it while you can..)

______________________________________________________________________________

And here is another program:

Disable Windows 10 Tracking
(C) 10se1ucgo
INSTRUCTIONS:
Download run.exe
Right click on 'run.exe' and press "RUN AS ADMINISTRATOR"
Choose any/all of the options you'd like
Press "Go Private!"
You can read the output at the bottom to see if it worked.
That's it! You can read the license at "Info -> About"
HISTORY:
Current version is v1.5
Changes since v1.4
* No longer assumes C:\ is the system drive
* Tooltips!
* 2nd Telemetry key modification
LINKS:
.
Homepage:
https://github.com/10se1ucgo/DisableWinTracking/
.
Download Releases:
https://github.com/10se1ucgo/DisableWinTracking/releases/

______________________________________________________________________________

and here is a a collection of BATCH scripts and TXT information:

win10-unfuck
(C) dfkt
Remove anti-privacy, anti-security, and general nuisance "features" from Windows 10.
Before running some of these scripts, you probably need 'real' admin access on your machine.
To disable UAC and elevate your privilege level to 'real' admin:
- Type secpol.msc in the Start Menu and press Enter.
- Double click on Local Policies then double click on Security Options
- Scroll to the bottom to this entry...
User Account Control: Run all administrators in Admin approval mode
Double click that line
- Set it to disabled then press OK
- Reboot
! ! ! W A R N I N G ! ! !
Disabling UAC using this method will break all Metro Store apps until enabled again, and the computer restarted.
Also data-harvesting-services-removal.bat will be flagged as malware, since it tries to automatically alter the hosts file.
You can either allow it, or add the hosts manually via the data-harvesting-hosts.txt file
LINKS:
.
Homepage:
https://github.com/dfkt/win10-unfuck

______________________________________________________________________________

And here is one of the best HOSTS file lists which attempts to totally blacklist Microsoft from your computer,
I did say attempts---read the comments!! There are 5,721 addresses in this list!! . . . . .

# ---------------------------------------------------------------------------- # Microsoft Hosts File Blocklist (updated Aug 12, 2015) # http://www.angelfire.com/comics2/fatboy9175/MShosts.txt # # NOTE: In WinXP SP2 or later, adding these lines to the HOSTS file won't be fully effective thanks to # Micro$haft's hidden rules in the "dnsapi.dll" file which override manual settings for certain M$-related # domains. To completely block Microsoft out of your system, you will have to add these to a third party # firewall, or hack dnsapi.dll, which I wouldn't advise unless you know what you're doing. You can open the # dll file with notepad or a hex editor to see all the domains included in Windows' hidden whitelist. # I recommend Acrylic DNS Proxy. It has its own hosts file that also supports wildcard rules, so instead # of needing thousands of entries that end in microsoft.com, you can just add *.microsoft.com and kill em all. # # NOTE 2: Due to the intrusiveness of Windows 10's Bing integration, I have now included ALL of Bing.com. # You didn't actually use Bing anyway, did you? :) #
0.0.0.0 0.r.msn.com
0.0.0.0 2wa1musicmix.phx.gbl
0.0.0.0 2wa2musicmix.phx.gbl
0.0.0.0 2wa3musicmix.phx.gbl
0.0.0.0 2wa4musicmix.phx.gbl
0.0.0.0 10.ds.mrs.microsoft.com
0.0.0.0 16miig.bay.livefilestore.com
0.0.0.0 1554.ic-live.com
0.0.0.0 778802.r.msn.com
0.0.0.0 946878.r.msn.com
0.0.0.0 1000626.r.msn.com
0.0.0.0 1822333.r.msn.com
0.0.0.0 1847742.r.msn.com
0.0.0.0 1847753.r.msn.com
0.0.0.0 1847767.r.msn.com
[...]
# ----------------------------------------------------------------------------

So we see that the Windows DNS resolver can and will ignore the HOSTS file for some MS domains,
however some text I saved from a 2006 forum posting seems to indicate that you may be able to control this by tweaking the values of a Registry key!

Here is the forum posting copied word-for-word as posted:

"Well in a twisted way it is in your control, but more of an all or nothing way. All these lookups ("Using XP") as an example are priority based. So in a sense you could over-ride those priorities ("Not suggested") here is what I mean....
If you look at this registry key on XP:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\ServiceProvider
You will see ('If you have the defaults'):
DNSPRIORITY: 2000
HOSTSPRIORITY: 500
LOCALPRIORITY: 499
NAME: TCP/IP
NETBTPRIORITY: 2001
PROVIDORPATH: %SystemRoot%\System32\wsock32.dll
The lower the priority ("If found there") trumps anything higher. Problem is,
Microsoft is nervous with their domain names and would much rather trust DNS in
all cases, no matter what you would like your other domain names to resolve by.
So, if you were to use these priorities which are default they would work like
this in this case, minus Microsoft Domains:
1. Local DNS Cache
2. Host file
3. ICS ("Depending on if you use it") hosts.ics
4. DNS
5. Wins
6. blah blah blah
So imagine if somehow your DNS cache was hacked, and redirected Microsoft sites
to another IP, you would be SCREWED in that case without this code in place.
Since DNS cache is used prior to the host file based on the default
priorities."

-- EOF --

My three favorite monospace fonts and text editors

04:23 PM

After a LOT of testing of just about every monospace font in existence, I have found this combination of three items to be my favorite for general-purpose everyday usage (on Windows):

Notepad "Source Code Pro, 9" Notepad2 "DejaVu Sans Mono, 8" Notepad++ "PragmataPro, 10"

Here is a side-by-side comparison screenshot of those three items displaying the same text file:
http://p.im9.eu/three-texteditors-fonts.jpg

Some other fonts looked nice too, but they were rejected for one reason or another such as "Unicode support" or "Not nice at certain sizes" etc etc. The three fonts I chose gave me the widest variation of views with the least (subjective) rejection qualities.

FYI, apart from many others, I tested all the fonts mentioned at this article:
http://www.slant.co/topics/67/~what-are-the-best-programming-fonts

—————————————————————————
Setup and Usage on my Windows PCs
—————————————————————————

I like having full read-write-access-delete permissions to everything ...including the entire Windows Registry :D
therefore, when I have a choice in the matter, I never setup programs under C:\Program Files\
and setup all third-party programs to subfolders under a created folder named C:\Progs\

So, for those three text editors, I have...
C:\Windows\notepad.exe ««««« location is not under my control
C:\Progs\Notepad2\notepad2.exe
C:\Progs\Notepad++\notepad++.exe

I add all three editors to the shell context menu like this example:

REGEDIT4
;--- Q: "REGEDIT4 vs Windows Registry Editor Version 5.00"
;--- REGEDIT4 is recognized in all versions of Windows including 2000/XP.
;--- The major difference between them is that "Version 5.00" is in Unicode format.
;---
;--- For REG file to be valid and error free:
;--- Append at least one blank line after "REGEDIT4" directive at start of file.
;--- Append at least one blank line at end of file.
;---
;--- Add context menu for Notepad2 text editor
;---
[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\*\shell\Edit with Notepad2...]
@="Edit with Notepad2..."
[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\*\shell\Edit with Notepad2...\command]
@="C:\\Progs\\Notepad2\\notepad2.exe %1"
[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\.lnk\shell\Edit with Notepad2...]
@="Edit with Notepad2..."
[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\.lnk\shell\Edit with Notepad2...\command]
@="C:\\Progs\\Notepad2\\notepad2.exe %1"
[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\InternetShortcut\shell\Edit with Notepad2...]
@="Edit with Notepad2..."
[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\InternetShortcut\shell\Edit with Notepad2...\command]
@="C:\\Progs\\Notepad2\\notepad2.exe %1"

SoylentNews

SoylentNews is people

Navigation

Sections

SoylentNews

Log In

number6 (1831)