Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 4 years ago.
Improve this question
Is there a Smalltalk equivalent of Inspect tool that is available for Microsoft Windows or something like inspect option available in Web browsers
From what I've researched, Smalltalk allows run-time reflection. I think this is more related to applications developed within the Smalltalk IDE.
I'm looking for an Inspect application for independent smalltalk EXEs.
I tried posting on SuperUser, but tags smalltalk was not available. I thought I might get answers here.
Such a tool could be created as a part of the Smalltalk application. However, trying to access objects from the outside without any help from within the Smalltalk system would be challenging because Smalltalk objects change their location very often (potentially, at every garbage collection) and therefore the external tool would need to somehow deduce the new location of the object from some fixed root known to it.
Now, if what you need is for debugging purposes, you could (in theory) halt the execution of the Smalltalk system and look for the object of interest in the object memory, tracing the instance variables as well, etc., resuming the execution of the Smalltalk exe when done. None of this is easy though, and that's why it would be much better if the Smalltalk application offered such a tool as an end-user feature.
Smalltalk is a language specification with many implementations. If available, tools for "external" debugging of Smalltalk applications will be vendor/implementation dependent.
Specific techniques for debugging a Smalltalk application without obvious access to a traditional Smalltalk development environment will vary between Smalltalk implementations. For example all GNU Smalltalk debugging is done without a Smalltalk IDE.1 There have been (are?) tools for "headless debugging" of Pharo applications. 2
Related
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 6 years ago.
Improve this question
I've been messing around with command prompt for a few days now, but I want to have a better understanding of what's actually going on under the hood. Searching the Internet has been of no use so far, as almost all the results there will show, you the syntax of the commands, which is not I want.
Is it possible to retrieve the source code for any of the Windows commands?
Source code for some parts of Windows is open sourced. .NET for example. Other parts of the source code are available via various programs, described here. One program that I've used is Code Center Premium. In this program you are assigned a smart card/PIN and use a specific URL to access the source code for the various versions of Windows. Generally only RTM (release to manufacturing) code is available on CCP (as opposed to patched versions of the code).
If you are an individual you probably won't be able to get access via any of these programs, except possibly the MVP program. But if you were an MVP you probably would already understand "what's going on under the hood" to a large extent.
As an individual I suggest the book Windows Internals, which you can find as a PDF on the web. Note that the book is over 1000 pages, so a huge amount of information is available within. Also, there are various examples in the book in the way of commands that control/monitor various aspects of Windows (no source code, but an explanation of how the command works)
Note that a book will be much more comprehensible than the Windows source code which if I remember correctly is well over 100,000,000 lines currently.
Note that for "vanilla" commands like COPY, DIR, etc., perusing the Win32 API set for file & directory I/O on MSDN will yield the APIs that CMD.EXE uses. Many samples are also available on MSDN and elsewhere.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 3 years ago.
Improve this question
I have recently discovered the amazing world of automated debugging, where your tool try to automatically isolate the part of the code that causes a bug. Since then, I have found some tools, like these:
delta debugging (implementation in DD.py) using scientific methodology applied to debugging.
static and dynamic program slicing extracting a subprogram trace highlighting the variables you want to observe.
git-bisect using bisection applied to code history and mixed with delta debugging to quickly find what change caused the bug.
I'm interested into finding more algorithms for automated debugging, which can automate some part (or all?) of the debugging process and where a pratical working implementation exists, particularly:
approaches such as delta debugging (which can precisely pinpoint where and why a bug happens in the code by using a systematic/automated approach).
is there a software that can automatically generate a minimal program that reproduces a bug from a full program?
NB: some tools I cited are mainly geared towards Python but I am looking for automated debugging tools on any language, what is interesting me is the approach and algorithms, not the specific implementation, but I require an implementation (even a proof of concept) because I would like algorithms which have already been practically applied to real problems (ie, they work, that's just not computer science philosophy).
Clarification: I'm not looking for automated testing tools (which automatically test to find a new bug), but automated debugging approaches where you have a specific bug you want to find the origin in your code.
I have found a few softwares that can generate a minimal program that reproduces a bug:
DD.py has in fact two functions: dd() to find the minimal change that introduced a bug, and ddmin() which finds the minimal configuration (ie, minimal test case).
Delta, a program specifically tailored for that purpose.
I also found a course on Udacity called Software Debugging which is presented by Andreas Zeller, the original author of delta debugging.
Side note: these are also somewhat related tools (although they are mainly unit testing tools, they can be used in combination with automated debugging so it's kind of related):
coveralls
coverage
automated unit test generator Pythoscope
I am still looking for alternative approaches to automated debugging.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 6 years ago.
Improve this question
Would really appreciate your help with Tcl/Tk testing framework. I am supposed to test a windows application written with Tcl/Tk, twapi, gdi 0.9.5.1. Do you know a black-box and/or white-box test framework that will help me with GUI testing (generate mouse event, etc etc, and drive the application)? What I expect from the test framework is something like what WindowsLicker allows you to do for Swing.
Tk can generate events with the event generate command, but it will only send these events to itself. You can combine these with the tcltest package to do such testing as you require.
That said, I actually advise splitting up your code so that there is a clear separation between the GUI and the functionality that powers it (the “business logic layer”, to borrow a phrase from server architectures). You can then test your baseline functionality thoroughly without having to fiddle around with testing GUIs, which is enormously easier. Once your BLL is working robustly, testing your GUI then becomes a matter of ensuring that actions in the GUI manipulate the view correctly or translate into appropriate BLL calls (which you know will either work correctly or fail in a way that is clear).
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 6 years ago.
Improve this question
Like many others, I always hold true that "A pure compiler will never exist for Ruby because the language is far too dynamic for a static compiler to work."
But I recently stumbled upon these:
The Crystal programming language at GitHub
Statically compiled Ruby
Both projects seem to be very interesting. They could give us the speed of a native-compiled language (and the often commercially-required, obfuscated code of a compiled language) while keeping all (or most) of the elegance and flexibility of Ruby. Add a good support library (or, more likely, the possibility to access the existing C++ libraries) and you can easily understand why this stuff could be interesting.
Has anybody tried the Crystal language?
(I didn't yet, because of compilation problems with ruby-llvm)
Which was his/her feeling about it?
Do you think that, given those design choices, would it be actually possible to develop a native-code (machine-code) compiler for Ruby (with a reasonable effort and in a reasonable amount of time)? Would it be meaningful?
I'm the developer of crystal. Currently not everything is implemented from the bulleted point list. In fact classes were just started to be implemented.
I really like the idea of it though. But I need to think more about how to implement it. And I also need more time, hehe.
The second article has a completely different approach because it won't introduce a new language: it'll just try to compile a subset of Ruby, or maybe will be compiled to native code but still allow some dynamism with performance costs (I talked to the author of that article some months ago).
My feeling toward both approaches: I really with it could happen. We need a fast language with an elegant, readable, joy to use syntax and library (like what Ruby offers).
I'm the developer of Foundry; the second article is mine.
A more recent article on the same topic would be "A language for embedded developers"; or you could also track development progress by subscribing at foundry-lang.org.
Please note, however, that my project is commercial, (at least initially) not open-source, and is primarily focused on embedded development. You could still use it on desktops or servers, of course.
I'm also one of ruby-llvm maintainers; please report the problems you've encountered as bugs on the project page.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 4 years ago.
Improve this question
On episode #41 of the Stack Overflow Podcast Jeff and Joel discussed GUI ideologies that lead to poor usability. What GUI toolkits have you seen that most beneficially influence the programmers that use them? What level of separation (between user-interface and implementation) do you find most efficient for testability and usability?
What GUI toolkits have you seen that most beneficially influence the programmers that use them?
My own, developed based on experience with computer science and the specific needs of the industry I develop for. In short there is no magic bullet just tools that you have to use experience and judgment with. What works for my CAD/CAM software, is not going to work for a web developer's website, nor for a developer of office software, and so on.
What level of separation (between user-interface and implementation) do you find most efficient for testability and usability?
For traditional applications that run on the desktop of a computer I recommend variants of the Passive View. The class responsible for creating and managing the form is a thin shell that passes events to the UI Object. The UI_Object interact with the form via a interface. In term the UI Object implements a UI_View Interface and registers itself with a View Controller that is situated lower in the object hierarchy.
The UI_Object then execute object implementing the Command Pattern which modifies the model. The command object can interacts with the various views via the interfaces exposed by the View Control.
What this does is allow you to rip off the form classes and replace them with stub classes that implement the form interfaces. The stub classes are used for automated testing especially for integration tests.
The interfaces precisely define the interaction between the Form, the UI_Object, Commands and the views. They can be designed to be relatively language agnostic so they can make porting between platform easier.
I am not as proficient with programming for the web but there are related patterns that accomplish the same thing.
I have to also caution that Passive View can be overkill. You may not want to use it for simple setup dialog (like the dialog setting up serial port parameters). This a judgment call on whether the ease of maintenance and coding is worth the added testing time. If a dialog is only called by a single command to modify some setup parameters then it is a good candidate to have it defined within the command itself.