Er...is there documentation for turbopower's OnGuard anywhere?
Finally got the source code to turn itself into components on the pallete (D2009) and can run the examples but I don't know what most of the components do or which I need.
There used to be documentation when it was a commercial product. Does it still exist?
Howard
Ah, I'd been looking for two days and eventually found the documentation five minutes after posting this message. To save anyone else the trouble they are here
http://sourceforge.net/projects/tponguard/files/tponguard_docs/1.13/
The documentation is still available on SourceForge, along with the source code.
Update: Most of the TurboPower components are being maintained as part of TurboPack, a collection of open source tools being kept up to date by Roman Kassebaum. The most recent versions of the source code and documentation for OnGuard are on GitHub.
For two examples on how to use the OnGuard library look at this question.
The two approaches there are roughly equivalent, Runner's answer creates the OnGuard components at runtime, while my answer uses the procedural OnGuard API and has slightly less overhead as a result.
There is a third approach of dropping the components on a form directly rather than creating them at runtime. There's nothing particularly wrong with doing this, I've just found it unnecessary and not really saving anything more than a line or two of code.
Related
The old FSharp Powerpack seems to be obsolete, and most of its components have moved to other projects. Where can I find the ArgParser module? Is it still maintained?
An improved version of ArgParser is maintained as part of ExtCore. If you're looking for a library of extended library functions, ExtCore is an excellent choice.
If you don't mind a few more files, just put Arg.fs and Arg.fsi into your projects. They're self-contained; I did it here without issue.
As the comment above suggested, you should give UnionArgParser a try (see their docs at http://nessos.github.io/UnionArgParser/). It is a well-maintained and fully declarative alternative; that is much better than ArgParser.
I am working with an undocumented, 100.000 lines Delphi 7 project and one of my goals is to create a software architecture document from the source code.
Can you give me any ideas on how to approach this?
These tools work with Delphi 7 and are of great help:
the UML tool ModelMaker
the refacotoring tool ModelMaker Code Explorer
the documentation tool Documentation Insight (as of august 2012)
UML diagrams are a great way to get an overview of structure. How well that overview is, depends on how well the structure is.
For taking over projects like these, I start with some basic documentation (often in MarkDown format, as that text based format is version control friendly, and generates nice HTML).
To get that going, it helps if the original developers or/and some base documentation are still there.
Then just start to:
fix bugs / apply feature requests
use ModelMaker to get a feel for overall structure
use ModelMaker Code Explorer as a refactoring tool
use Documentation Insight to document inside the source code (you can generate help files and web pages with the pro version, see feature matrix)
update my Markdown documents with any information that does not fit in the source code documentation well
Note you can put some documentation in using Model Maker Code Explorer, but it can not be exported as help files, since it uses a different documentation format than Documentation Insight.
So I agree with the comment by Jan Doggen (thanks Jan!): just start. Make sure you have the right tools to help that going.
Try running the source code through a newer Delphi version that supports UML modeling, then let it show you how different sections of code related to each other.
Understand will do the job. Free download includes 15 days evaluation which will be more then enough for what you need to document.
What component or method can be used to specify a list of filenames and then zip them into a single archive?
I dont need advanced features or anything really, but if I could add some filenames to a stringlist for example then put those files into a ZIP that would be good.
Ive tried searching a few components but not sure which ones to use.
Thanks
In addition to VCLZip that Chris mentioned, Abbrevia (one of the old TurboPower packages) is available for free at SourceForge. If you need Delphi 2010/XE versions, you can find those available at SongBeamer (if the changes haven't been incorporated into the SF tree yet). As I was well educated about in the comments to my answer, the D2010/XE changes (as well as many bugfixes and new features) have been added to the project at SF, so the SongBeamer version is no longer needed.
VCLZip is good, fairly popular. http://vclzip.bizland.com/ IIRC, it has good documentation and examples that will get you off to a quick start.
I have used sometimes ZipMaster, and it works well.
Regards.
We're trying to untangle a hairball of 100's of units, removing some.
It would be helpful if there was tool that would show us what units were explicitly using unit X.
Penganza doesn't seem to have a report that does that. (Although it has lots of other useful reports.)
Can anyone suggest a tool or strategy for doing this, other than just hiding unit x and then hitting F9 ... repeatedly?
MMX (Model Maker Code Explorer) has a nice unit dependency analyzer (it is especially good at detecting cycles).
For more details, see this answer.
--jeroen
From a similar question here
You might want to take a look at at
CnPack.
CnPack includes a Uses cleaner
wizard wich hasn't failed me yet.
GExperts can show Project Dependencies.
Peganza Pascal Analyzer can do the work. I haven't worked with it much, but a former dev here wrote a system that uses PAL to do the analysis, then dumped the results into a database, and then there's a browser app that lets you enter a unit name and it returns the list of units affected, whether they would need to be rebuilt if the unit changed, or if the interface changed. We use lots of BPLs so you can sometimes change a unit and you don't have to re-build other binaries that use your unit, unless the interface changed. This saves us lots of work (hundreds of BPLs and EXEs).
Chris
Headway Software's Structure 101g (and Restructure 101g) can do that really well, with the Delphi plugin.
Disclaimer: I wrote the flavors to analyze Delphi. I use them professionally, helping clients.
We've just released a freeware utility that does exactly what you need plus quite a bit more. It's called the Delphi Unit Dependency Scanner (DUDs) and you can download it here: http://www.easy-ip.net/delphi-unit-dependency-scanner.html
Sorry it's a bit late!
I was going to mention Icarus, but when I googled them I got this stack overflow answer, which you might want to check out.
Then again, sometimes I just like to delete my whole Unit Output Directory, then count my new DCU's, and that works too.
The reason you may like Icarus and not GExperts is that it doesn't rely on you to have properly maintained the uses statements in your project file.
A newcomer in this field is the Delphi Plugin for Sonar. It does not list unit dependencies but can find unused files and "dead" code (and more).
Implemented features:
Counting lines of code, statements, number of files
Counting number of classes, number of packages, methods, accessors
Counting number of public API (methods, classes and fields)
Counting comments ratio, comment lines (including blank lines)
CPD (code duplication, how many lines, block and in how many files)
Code Complexity (per method, class, file; complexity distribution
over methods, classes and files)
LCOM4 and RFC
Code colorization
Unit tests reports
Assembler syntax in grammar
Include statement
Parsing preprocessor statements
Rules
Code coverage reports
Source code highlight for unit tests
“Dead” code recognition
Unused files recognition
If you have been successful in persisting your data, which type of stream did you get to work
Text or Binary
ANSI or UNICODE
Did you have to use any BOOST_ASSERTS or some extra MACRO or dance around the fairy ring at 4:00 am wearing your Moose sweater backwards.
Thanks for your answer
There is a posting for C++Builder 2010 (unfortunately I do not know of one for 2009), that shows the portions of the Boost (1.39) that are included in the shipping product. The serialization library is listed as not supported. Note the posting also includes a link to the source code they used in case someone wants to experiment with the unsupported libraries.
I haven't tried, so I can't directly answer. However, here are the boost 1.37.0 test results for C++Builder 2009 (the column on the right, "borland-6.1.0").
You can see most things in 'serialization' pass the tests. Some don't, so if you compare what you're trying to do to those it should help you to know what to avoid. The test suites may also useful to you, because they can be used as code examples for using the features they test.
You may find other resources on the C++ Builder Boost page to be useful too.