Search Results

Search found 1968 results on 79 pages for 'pickle dump'.

Page 24/79 | < Previous Page | 20 21 22 23 24 25 26 27 28 29 30 31  | Next Page >

• Spare PC with XP to be used as Torrent Downloader and local Web Server HOWTO?

  - by gslide

  Hi I'm a bit in a pickle in trying to setup my old laptop using Windows XP to be able to serve as two devices in one, I want to make it a downloader for torrents and a local web server as well and how to do this? I have a wireless NIC and LAN, and I have two internet connections and i would like to be able to download torrent only on LAN and be a webserver on the Wireless, also the webserver can be accessed through the internet. The reason for trying to separate the connection is I can't have torrent downloads using all my bandwidth as my web pages cant be access as it times out or too slow. I have two broadband connections, is this even possible or would i need a different OS or program that I can download? please

  Read the article

• Jack of all trades, master of none [closed]

  - by Rope

  I've got a question similar to this one: Is looking for code examples constantly a sign of a bad developer? though not entirely. I got off college 2 years ago and I'm currently struggling with a University study. Most likely I'll have to drop out and start working within the next couple of months. Now here's the pickle. I have no speciality what so ever. When I got out of college I had worked with C, C++ and Java. I had had an internship at NEC-Philips and got familiar with C# (.NET) and I taught myself how it worked. After college I started working with PHP, HTML,SQL, MySQL Javascript and Jquery. I'm currently teaching myself Ruby on Rails and thus Ruby. At my university I also got familiar with MATLAB. As you can see I've got a broad scope of languages and frameworks I'm familiar with, but none I know inside-out. So I guess this kinda applies to me: "Jack of all trades, master of none.". I've been looking for jobs and I've noticed that most of them require some years of experience with a certain language and some specifications that apply to that language. My question is: How do I pick a speciality? And how do I know if I'll actually enjoy it? As I've worked with loads of languages how would I be able to tell this is right for me? I don't like being tied down to a specific role and I quite like being a generalist. But in order to make more money I would need a specialisation. How would I pick something that goes against my nature? Thanks in advance, Rope.

  Read the article

• Podcasting vs Stack Overflow vs Geekswithblogs

  - by MarkPearl

  For a few years now I have been looking for effective ways to be involved in the “community”. While there are a few community programming events in my area (Johannesberg), there isn’t too much face to face stuff – which has caused me to turn to the internet. My internet attempts have been varied – at first I took the passive approach of listening to tech podcasts. This was great for a while, but soon the content became semi-repetitive and a little boring. It seemed that the podcasts I was listening to all went round the same themes and speakers and while I am still a keen listener to several tech podcasts – it didn’t quench my thirst. So I began to be a bit more active – starting with stack overflow – where I would scan the site for questions that were in the realm of my ability to answer. It worked for a while but soon it began to be discouraging – there seems to be so many people that know so much more than me and are quicker at typing that I felt fairly ineffective. So while I still use Stack Overflow when I am in a pickle and need some help – it feels more like me taking from the community than giving anything. Which brought me to Geeks with blogs. Till I found GWB I hadn’t felt like I was an active part of a community. I had blogged before on Blogspot and Wordpress but hadn’t felt associated to the community. Now when I get a comment from someone on one of my GWB posts either thanking me or adding a bit more or correcting me, it makes me feel like I am contributing to a community. So well done GWB. Thanks for making a spot that makes me feel at home!

  Read the article

• Dell Docking Station Doesn’t Detect USB Mouse and Keyboard

  - by Ben Griswold

  I’ve found myself in this situation with multiple Dell docking stations and multiple Dell laptops running various Windows operating systems.  I don’t know why the docking station stops recognizing my USB mouse and keyboard – it just does.  It’s black magic.  The last time around I just starting plugging the mouse and keyboard into the docked laptop directly and went about my business (as if I wasn’t completing missing out on a couple of the core benefits of using a docking station.)  I guess that’s what happens when you forget how you got yourself out of the mess the last time around.  I had been in this half-assed state for a couple of weeks now, but a coworker fortunately got themselves in and out of the same pickle this morning.  Procrastinate long enough and the solution will just come to you, right? Here’s how to get yourself out of this mess: Undock your computer Unplug your docking station Count to an arbitrary number greater than 12.  (Not sure this is really required, but…) Plug your docking station back in Redock your machine I put my machine to sleep before taking the aforementioned actions.  My coworker completely shutdown his laptop instead.  The steps worked on both of our Win 7 machines this morning and, who knows, it might just work for you too. 

  Read the article

• Introduction to LinqPad Driver for StreamInsight 2.1

  - by Roman Schindlauer

  We are announcing the availability of the LinqPad driver for StreamInsight 2.1. The purpose of this blog post is to offer a quick introduction into the new features that we added to the StreamInsight LinqPad driver. We’ll show you how to connect to a remote server, how to inspect the entities present of that server, how to compose on top of them and how to manage their lifetime. Installing the driver Info on how to install the driver can be found in an earlier blog post here. Establishing connections As you click on the “Add Connection” link in the left pane you will notice that now it’s possible to build the data context automatically. The new driver appears as an option in the upper list, and if you pick it you will open a connection dialog that lets you connect to a remote StreamInsight server. The connection dialog lets you specify the address of the remote server. You will notice that it’s possible to pick up the binding information from the configuration file of the LinqPad application (which is normally in the same folder as LinqPad.exe and is called LinqPad.exe.config). In order for the context to be generated you need to pick an application from the server. The control is editable hence you can create a new application if you don’t want to make changes to an existing application. If you choose a new application name you will be prompted for confirmation before this gets created. Once you click OK the connection is created and you can start issuing queries against the remote server. If there’s any connectivity error the connection is marked with a red X and you can see the error message informing you what went wrong (i.e., the remote server could not be reached etc.). The context for remote servers Let’s take a look at what happens after we are connected successfully. Every LinqPad query runs inside a context – think of it as a class that wraps all the code that you’re writing. If you’re connecting to a live server the context will contain the following: The application object itself. All entities present in this application (sources, sinks, subjects and processes). The picture below shows a snapshot of the left pane of LinqPad after a successful connection. Every entity on the server has a different icon which will allow users to figure out its purpose. You will also notice that some entities have a string in parentheses following the name. It should be interpreted as such: the first name is the name of the property of the context class and the second name is the name of the entity as it exists on the server. Not all valid entity names are valid identifier names so in cases where we had to make a transformation you see both. Note also that as you hover over the entities you get IntelliSense with their types – more on that later. Remoting is not supported As you play with the entities exposed by the context you will notice that you can’t read and write directly to/from them. If for instance you’re trying to dump the content of an entity you will get an error message telling you that in the current version remoting is not supported. This is because the entity lives on the remote server and dumping its content means reading the events produced by this entity into the local process. ObservableSource.Dump(); Will yield the following error: Reading from a remote 'System.Reactive.Linq.IQbservable`1[System.Int32]' is not supported. Use the 'Microsoft.ComplexEventProcessing.Linq.RemoteProvider.Bind' method to read from the source using a remote observer. This basically tells you that you can call the Bind() method to direct the output of this source to a sink that has to be defined on the remote machine as well. You can’t bring the results to the LinqPad window unless you write code specifically for that. Compose queries You may ask – what's the purpose of all that? After all the same information is present in the EventFlowDebugger, why bother with showing it in LinqPad? First of all, What gets exposed in LinqPad is not what you see in the debugger. In LinqPad we have a property on the context class for every entity that lives on the server. Because LinqPad offers IntelliSense we in fact have much more information about the entity, and more importantly we can compose with that entity very easily. For example, let’s say that this code creates an entity: using (var server = Server.Connect(...)) {     var a = server.CreateApplication("WhiteFish");     var src = a         .DefineObservable<int>(() => Observable.Range(0, 3))         .Deploy("ObservableSource"); If later we want to compose with the source we have to fetch it and then we can bind something to     a.GetObservable<int>("ObservableSource)").Bind(... This means that we had to know a bunch of things about this: that it’s a source, that it’s an observable, it produces a result with payload Int32 and it’s named “ObservableSource”. Only the second and last bits of information are present in the debugger, by the way. As you type in the query window you see that all the entities are present, you get IntelliSense support for them and it’s much easier to make sense of what’s available. Let’s look at a scenario where composition is plausible. With the new programming model it’s possible to create “cold” sources that are parameterized. There was a way to accomplish that even in the previous version by passing parameters to the adapters, but this time it’s much more elegant because the expression declares what parameters are required. Say that we hover the mouse over the ThrottledSource source – we will see that its type is Func<int, int, IQbservable<int>> - this in effect means that we need to pass two int parameters before we can get a source that produces events, and the type for those events is int – in the particular case of my example I had the source produce a range of integers and the two parameters were the start and end of the range. So we see how a developer can create a source that is not running yet. Then someone else (e.g. an administrator) can pass whatever parameters appropriate and run the process. Proxy Types Here’s an interesting scenario – what if someone created a source on a server but they forgot to tell you what type they used. Worse yet, they might have used an anonymous type and even though they can refer to it by name you can’t figure out how to use that type. Let’s walk through an example that shows how you can compose against types you don’t need to have the definition of. This is how we can create a source that returns an anonymous type: Application.DefineObservable(() => Observable.Range(1, 10).Select(i => new { I = i })).Deploy("O1"); Now if we refresh the connection we can see the new source named O1 appear in the list. But what’s more important is that we now have a type to work with. So we can compose a query that refers to the anonymous type. var threshold = new StreamInsightDynamicDriver.TypeProxies.AnonymousType1_0<int>(5); var filter = from i in O1              where i > threshold              select i; filter.Deploy("O2"); You will notice that the anonymous type defined with this statement: new { I = i } can now be manipulated by a client that does not have access to it because the LinqPad driver has generated another type in its stead, named StreamInsightDynamicDriver.TypeProxies.AnonymousType1_0. This type has all the properties and fields of the type defined on the server, except in this case we can instantiate values and use it to compose more queries. It is worth noting that the same thing works for types that are not anonymous – the test is if the LinqPad driver can resolve the type or not. If it’s not possible then a new type will be generated that approximates the type that exists on the server. Control metadata In addition to composing processes on top of the existing entities we can do other useful things. We can delete them – nothing new here as we simply access the entities through the Entities collection of the application class. Here is where having their real name in parentheses comes handy. There’s another way to find out what’s behind a property – dump its expression. The first line in the output tells us what’s the name of the entity used to build this property in the context. Runtime information So let’s create a process to see what happens. We can bind a source to a sink and run the resulting process. If you right click on the connection you can refresh it and see the process present in the list of entities. Then you can drag the process to the query window and see that you can have access to process object in the Processes collection of the application. You can then manipulate the process (delete it, read its diagnostic view etc.). Regards, The StreamInsight Team

  Read the article

• Ethernet card not detected on Ubuntu Server 12.04

  - by Dana

  My onboard ethernet isn't detected after a re-install of Server 12.04. For reasons I won't get into here, I had to put the server's drive into another machine to install Ubuntu, then swap back into the server. So the server starts up fine, except for the "Waiting for network configuration". I read in another article that Server, by default, doesn't handle new mac addresses for hardware changes dynamically, unlike Ubuntu Desktop, but a look at /etc/udev/rules.d/70-persistent-net.rules shows only one ethernet interface. Shouldn't it show both the old, and the new? lspci -vv shows an ethernet interface, so what the heck is going on? I should mention that the onboard LAN is enabled in the BIOS. And I know this isn't important, but all this started when I changed some network configuration settings in webmin before the re-install. It couldn't download any updates, so I tinkered a little. Broke, it, installed FreeNAS, which worked, but I didn't like it, then went back to Ubuntu Server, and now I'm in this pickle. Thanks for any advice!

  Read the article

• Introduction to LinqPad Driver for StreamInsight 2.1

  - by Roman Schindlauer

  We are announcing the availability of the LinqPad driver for StreamInsight 2.1. The purpose of this blog post is to offer a quick introduction into the new features that we added to the StreamInsight LinqPad driver. We’ll show you how to connect to a remote server, how to inspect the entities present of that server, how to compose on top of them and how to manage their lifetime. Installing the driver Info on how to install the driver can be found in an earlier blog post here. Establishing connections As you click on the “Add Connection” link in the left pane you will notice that now it’s possible to build the data context automatically. The new driver appears as an option in the upper list, and if you pick it you will open a connection dialog that lets you connect to a remote StreamInsight server. The connection dialog lets you specify the address of the remote server. You will notice that it’s possible to pick up the binding information from the configuration file of the LinqPad application (which is normally in the same folder as LinqPad.exe and is called LinqPad.exe.config). In order for the context to be generated you need to pick an application from the server. The control is editable hence you can create a new application if you don’t want to make changes to an existing application. If you choose a new application name you will be prompted for confirmation before this gets created. Once you click OK the connection is created and you can start issuing queries against the remote server. If there’s any connectivity error the connection is marked with a red X and you can see the error message informing you what went wrong (i.e., the remote server could not be reached etc.). The context for remote servers Let’s take a look at what happens after we are connected successfully. Every LinqPad query runs inside a context – think of it as a class that wraps all the code that you’re writing. If you’re connecting to a live server the context will contain the following: The application object itself. All entities present in this application (sources, sinks, subjects and processes). The picture below shows a snapshot of the left pane of LinqPad after a successful connection. Every entity on the server has a different icon which will allow users to figure out its purpose. You will also notice that some entities have a string in parentheses following the name. It should be interpreted as such: the first name is the name of the property of the context class and the second name is the name of the entity as it exists on the server. Not all valid entity names are valid identifier names so in cases where we had to make a transformation you see both. Note also that as you hover over the entities you get IntelliSense with their types – more on that later. Remoting is not supported As you play with the entities exposed by the context you will notice that you can’t read and write directly to/from them. If for instance you’re trying to dump the content of an entity you will get an error message telling you that in the current version remoting is not supported. This is because the entity lives on the remote server and dumping its content means reading the events produced by this entity into the local process. ObservableSource.Dump(); Will yield the following error: Reading from a remote 'System.Reactive.Linq.IQbservable`1[System.Int32]' is not supported. Use the 'Microsoft.ComplexEventProcessing.Linq.RemoteProvider.Bind' method to read from the source using a remote observer. This basically tells you that you can call the Bind() method to direct the output of this source to a sink that has to be defined on the remote machine as well. You can’t bring the results to the LinqPad window unless you write code specifically for that. Compose queries You may ask – what's the purpose of all that? After all the same information is present in the EventFlowDebugger, why bother with showing it in LinqPad? First of all, What gets exposed in LinqPad is not what you see in the debugger. In LinqPad we have a property on the context class for every entity that lives on the server. Because LinqPad offers IntelliSense we in fact have much more information about the entity, and more importantly we can compose with that entity very easily. For example, let’s say that this code creates an entity: using (var server = Server.Connect(...)) {     var a = server.CreateApplication("WhiteFish");     var src = a         .DefineObservable<int>(() => Observable.Range(0, 3))         .Deploy("ObservableSource"); If later we want to compose with the source we have to fetch it and then we can bind something to     a.GetObservable<int>("ObservableSource)").Bind(... This means that we had to know a bunch of things about this: that it’s a source, that it’s an observable, it produces a result with payload Int32 and it’s named “ObservableSource”. Only the second and last bits of information are present in the debugger, by the way. As you type in the query window you see that all the entities are present, you get IntelliSense support for them and it’s much easier to make sense of what’s available. Let’s look at a scenario where composition is plausible. With the new programming model it’s possible to create “cold” sources that are parameterized. There was a way to accomplish that even in the previous version by passing parameters to the adapters, but this time it’s much more elegant because the expression declares what parameters are required. Say that we hover the mouse over the ThrottledSource source – we will see that its type is Func<int, int, IQbservable<int>> - this in effect means that we need to pass two int parameters before we can get a source that produces events, and the type for those events is int – in the particular case of my example I had the source produce a range of integers and the two parameters were the start and end of the range. So we see how a developer can create a source that is not running yet. Then someone else (e.g. an administrator) can pass whatever parameters appropriate and run the process. Proxy Types Here’s an interesting scenario – what if someone created a source on a server but they forgot to tell you what type they used. Worse yet, they might have used an anonymous type and even though they can refer to it by name you can’t figure out how to use that type. Let’s walk through an example that shows how you can compose against types you don’t need to have the definition of. This is how we can create a source that returns an anonymous type: Application.DefineObservable(() => Observable.Range(1, 10).Select(i => new { I = i })).Deploy("O1"); Now if we refresh the connection we can see the new source named O1 appear in the list. But what’s more important is that we now have a type to work with. So we can compose a query that refers to the anonymous type. var threshold = new StreamInsightDynamicDriver.TypeProxies.AnonymousType1_0<int>(5); var filter = from i in O1              where i > threshold              select i; filter.Deploy("O2"); You will notice that the anonymous type defined with this statement: new { I = i } can now be manipulated by a client that does not have access to it because the LinqPad driver has generated another type in its stead, named StreamInsightDynamicDriver.TypeProxies.AnonymousType1_0. This type has all the properties and fields of the type defined on the server, except in this case we can instantiate values and use it to compose more queries. It is worth noting that the same thing works for types that are not anonymous – the test is if the LinqPad driver can resolve the type or not. If it’s not possible then a new type will be generated that approximates the type that exists on the server. Control metadata In addition to composing processes on top of the existing entities we can do other useful things. We can delete them – nothing new here as we simply access the entities through the Entities collection of the application class. Here is where having their real name in parentheses comes handy. There’s another way to find out what’s behind a property – dump its expression. The first line in the output tells us what’s the name of the entity used to build this property in the context. Runtime information So let’s create a process to see what happens. We can bind a source to a sink and run the resulting process. If you right click on the connection you can refresh it and see the process present in the list of entities. Then you can drag the process to the query window and see that you can have access to process object in the Processes collection of the application. You can then manipulate the process (delete it, read its diagnostic view etc.). Regards, The StreamInsight Team

  Read the article

• The Return Of __FILE__ And __LINE__ In .NET 4.5

  - by Alois Kraus

  Good things are hard to kill. One of the most useful predefined compiler macros in C/C++ were __FILE__ and __LINE__ which do expand to the compilation units file name and line number where this value is encountered by the compiler. After 4.5 versions of .NET we are on par with C/C++ again. It is of course not a simple compiler expandable macro it is an attribute but it does serve exactly the same purpose. Now we do get CallerLineNumberAttribute  == __LINE__ CallerFilePathAttribute        == __FILE__ CallerMemberNameAttribute  == __FUNCTION__ (MSVC Extension)   The most important one is CallerMemberNameAttribute which is very useful to implement the INotifyPropertyChanged interface without the need to hard code the name of the property anymore. Now you can simply decorate your change method with the new CallerMemberName attribute and you get the property name as string directly inserted by the C# compiler at compile time.   public string UserName { get { return _userName; } set { _userName=value; RaisePropertyChanged(); // no more RaisePropertyChanged(“UserName”)! } } protected void RaisePropertyChanged([CallerMemberName] string member = "") { var copy = PropertyChanged; if(copy != null) { copy(new PropertyChangedEventArgs(this, member)); } } Nice and handy. This was obviously the prime reason to implement this feature in the C# 5.0 compiler. You can repurpose this feature for tracing to get your hands on the method name of your caller along other stuff very fast now. All infos are added during compile time which is much faster than other approaches like walking the stack. The example on MSDN shows the usage of this attribute with an example public static void TraceMessage(string message, [CallerMemberName] string memberName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0) { Console.WriteLine("Hi {0} {1} {2}({3})", message, memberName, sourceFilePath, sourceLineNumber); }   When I do think of tracing I do usually want to have a API which allows me to Trace method enter and leave Trace messages with a severity like Info, Warning, Error When I do print a trace message it is very useful to print out method and type name as well. So your API must either be able to pass the method and type name as strings or extract it automatically via walking back one Stackframe and fetch the infos from there. The first glaring deficiency is that there is no CallerTypeAttribute yet because the C# compiler team was not satisfied with its performance.   A usable Trace Api might therefore look like   enum TraceTypes { None = 0, EnterLeave = 1 << 0, Info = 1 << 1, Warn = 1 << 2, Error = 1 << 3 } class Tracer : IDisposable { string Type; string Method; public Tracer(string type, string method) { Type = type; Method = method; if (IsEnabled(TraceTypes.EnterLeave,Type, Method)) { } } private bool IsEnabled(TraceTypes traceTypes, string Type, string Method) { // Do checking here if tracing is enabled return false; } public void Info(string fmt, params object[] args) { } public void Warn(string fmt, params object[] args) { } public void Error(string fmt, params object[] args) { } public static void Info(string type, string method, string fmt, params object[] args) { } public static void Warn(string type, string method, string fmt, params object[] args) { } public static void Error(string type, string method, string fmt, params object[] args) { } public void Dispose() { // trace method leave } } This minimal trace API is very fast but hard to maintain since you need to pass in the type and method name as hard coded strings which can change from time to time. But now we have at least CallerMemberName to rid of the explicit method parameter right? Not really. Since any acceptable usable trace Api should have a method signature like Tracexxx(… string fmt, params [] object args) we not able to add additional optional parameters after the args array. If we would put it before the format string we would need to make it optional as well which would mean the compiler would need to figure out what our trace message and arguments are (not likely) or we would need to specify everything explicitly just like before . There are ways around this by providing a myriad of overloads which in the end are routed to the very same method but that is ugly. I am not sure if nobody inside MS agrees that the above API is reasonable to have or (more likely) that the whole talk about you can use this feature for diagnostic purposes was not a core feature at all but a simple byproduct of making the life of INotifyPropertyChanged implementers easier. A way around this would be to allow for variable argument arrays after the params keyword another set of optional arguments which are always filled by the compiler but I do not know if this is an easy one. The thing I am missing much more is the not provided CallerType attribute. But not in the way you would think of. In the API above I did add some filtering based on method and type to stay as fast as possible for types where tracing is not enabled at all. It should be no more expensive than an additional method call and a bool variable check if tracing for this type is enabled at all. The data is tightly bound to the calling type and method and should therefore become part of the static type instance. Since extending the CLR type system for tracing is not something I do expect to happen I have come up with an alternative approach which allows me basically to attach run time data to any existing type object in super fast way. The key to success is the usage of generics.   class Tracer<T> : IDisposable { string Method; public Tracer(string method) { if (TraceData<T>.Instance.Enabled.HasFlag(TraceTypes.EnterLeave)) { } } public void Dispose() { if (TraceData<T>.Instance.Enabled.HasFlag(TraceTypes.EnterLeave)) { } } public static void Info(string fmt, params object[] args) { } /// <summary> /// Every type gets its own instance with a fresh set of variables to describe the /// current filter status. /// </summary> /// <typeparam name="T"></typeparam> internal class TraceData<UsingType> { internal static TraceData<UsingType> Instance = new TraceData<UsingType>(); public bool IsInitialized = false; // flag if we need to reinit the trace data in case of reconfigured trace settings at runtime public TraceTypes Enabled = TraceTypes.None; // Enabled trace levels for this type } } We do not need to pass the type as string or Type object to the trace Api. Instead we define a generic Api that accepts the using type as generic parameter. Then we can create a TraceData static instance which is due to the nature of generics a fresh instance for every new type parameter. My tests on my home machine have shown that this approach is as fast as a simple bool flag check. If you have an application with many types using tracing you do not want to bring the app down by simply enabling tracing for one special rarely used type. The trace filter performance for the types which are not enabled must be therefore the fasted code path. This approach has the nice side effect that if you store the TraceData instances in one global list you can reconfigure tracing at runtime safely by simply setting the IsInitialized flag to false. A similar effect can be achieved with a global static Dictionary<Type,TraceData> object but big hash tables have random memory access semantics which is bad for cache locality and you always need to pay for the lookup which involves hash code generation, equality check and an indexed array access. The generic version is wicked fast and allows you to add more features to your tracing Api with minimal perf overhead. But it is cumbersome to write the generic type argument always explicitly and worse if you do refactor code and move parts of it to other classes it might be that you cannot configure tracing correctly. I would like therefore to decorate my type with an attribute [CallerType] class Tracer<T> : IDisposable to tell the compiler to fill in the generic type argument automatically. class Program { static void Main(string[] args) { using (var t = new Tracer()) // equivalent to new Tracer<Program>() { That would be really useful and super fast since you do not need to pass any type object around but you do have full type infos at hand. This change would be breaking if another non generic type exists in the same namespace where now the generic counterpart would be preferred. But this is an acceptable risk in my opinion since you can today already get conflicts if two generic types of the same name are defined in different namespaces. This would be only a variation of this issue. When you do think about this further you can add more features like to trace the exception in your Dispose method if the method is left with an exception with that little trick I did write some time ago. You can think of tracing as a super fast and configurable switch to write data to an output destination or to execute alternative actions. With such an infrastructure you can e.g. Reconfigure tracing at run time. Take a memory dump when a specific method is left with a specific exception. Throw an exception when a specific trace statement is hit (useful for testing error conditions). Execute a passed delegate which e.g. dumps additional state when enabled. Write data to an in memory ring buffer and dump it when specific events do occur (e.g. method is left with an exception, triggered from outside). Write data to an output device. …. This stuff is really useful to have when your code is in production on a mission critical server and you need to find the root cause of sporadic crashes of your application. It could be a buggy graphics card driver which throws access violations into your application (ok with .NET 4 not anymore except if you enable a compatibility flag) where you would like to have a minidump or you have reached after two weeks of operation a state where you need a full memory dump at a specific point in time in the middle of an transaction. At my older machine I do get with this super fast approach 50 million traces/s when tracing is disabled. When I do know that tracing is enabled for this type I can walk the stack by using StackFrameHelper.GetStackFramesInternal to check further if a specific action or output device is configured for this method which is about 2-3 times faster than the regular StackTrace class. Even with one String.Format I am down to 3 million traces/s so performance is not so important anymore since I do want to do something now. The CallerMemberName feature of the C# 5 compiler is nice but I would have preferred to get direct access to the MethodHandle and not to the stringified version of it. But I really would like to see a CallerType attribute implemented to fill in the generic type argument of the call site to augment the static CLR type data with run time data.

  Read the article

• responsibility for storage

  - by Stefano Borini

  A colleague and I were brainstorming about where to put the responsibility of an object to store itself on the disk in our own file format. There are basically two choices: object.store(file) fileformatWriter.store(object) The first one gives the responsibility of serialization on the disk to the object itself. This is similar to the approach used by python pickle. The second groups the representation responsibility on a file format writer object. The data object is just a plain data container (eventually with additional methods not relevant for storage). We agreed on the second methodology, because it centralizes the writing logic from generic data. We also have cases of objects implementing complex logic that need to store info while the logic is in progress. For these cases, the fileformatwriter object can be passed and used as a delegate, calling storage operations on it. With the first pattern, the complex logic object would instead accept the raw file, and implement the writing logic itself. The first method, however, has the advantage that the object knows how to write and read itself from any file containing it, which may also be convenient. I would like to hear your opinion before starting a rather complex refactoring.

  Read the article

• An entry-level programmer's best option [on hold]

  - by user134409

  I am facing a puzzle and I am not sure the best way to make a decision. In my spare time besides playing video games I got around to develop some games, nothing fancy, just small projects to get a better grasp at programming. After I finished college and got my BA in Computer Science, I got a job as web developer at a small firm. The next few months were very stressful as I had no previous experience and tried my best to make up for it. But after 6 months my boss told me I was inefficient and not very independent and let me go. To my credit, the help from the senior was very limited, I did learn a lot but I have learned by myself. For example they told me to do a UI in BackboneJS and I took me a while but I got it working (even if it was poorly designed). But I managed to do it all by myself because my senior was very busy and he did not have time even for my questions. Now I have found a new job again in web development but I am very afraid of what is going to happen next. I am afraid because I don't want to take the job and then be fired again after a couple of months, I get the feeling that this will be very bad on my CV, job hopping is like a red flag. They want to hire me but I am aware that they are working with new technologies and maybe I will end up not coping with it. So the question is: Should a entry-level programmer be better off with a starting job in QA, testing and work his way from there? I did learn allot from my first job but it was a moral blow when they decided to fire me. I do have a low self-esteem and I know my skills as a programmer are not that great. But I like programming and want to get better and I want to have a long career in it so that basically my pickle. Thank you in advance for the answers.

  Read the article

• Debugging Silverlight crash

  - by RHLopez

  I am trying to debug an IE 8 crash caused by a Silverlight application. I managed to find some articles on how to do a memory dump when a process crashes. I loaded the dump in windbg and ran !analyze -v. Below is the result. I am stuck at what further steps I can take to figure out what module or library that is running in Silverlight is causing the crash. So all I have right now is the crash in IE is caused by an Access violation (attempt to execute non-executable address) and from what is in the stack trace that some animation is running in Silverlight. Any tips or articles that would help me debug this will be appreciated. This dump file has an exception of interest stored in it. The stored exception information can be accessed via .ecxr. (1864.1560): Access violation - code c0000005 (first/second chance not available) eax=00000000 ebx=00000000 ecx=1b11fc58 edx=5c6f007d esi=00000000 edi=193b8e08 eip=00000000 esp=0f61f750 ebp=0f61f76c iopl=0 nv up ei pl nz na pe nc cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010206 00000000 ?? ??? FAULTING_IP: +56b3952f04ebde68 748bc9f1 654c dec esp EXCEPTION_RECORD: ffffffff -- (.exr 0xffffffffffffffff) ExceptionAddress: 748bc9f1 ExceptionCode: c0000005 (Access violation) ExceptionFlags: 00000000 NumberParameters: 2 Parameter[0]: 00000008 Parameter[1]: 00000000 Attempt to execute non-executable address 00000000 PROCESS_NAME: iexplore.exe ERROR_CODE: (NTSTATUS) 0xc0000005 - The instruction at 0x%08lx referenced memory at 0x%08lx. The memory could not be %s. EXCEPTION_CODE: (NTSTATUS) 0xc0000005 - The instruction at 0x%08lx referenced memory at 0x%08lx. The memory could not be %s. EXCEPTION_PARAMETER1: 00000008 EXCEPTION_PARAMETER2: 00000000 WRITE_ADDRESS: 00000000 FOLLOWUP_IP: agcore!CFrameworkElement::SetValue+1d7 5c704fa8 84c0 test al,al FAILED_INSTRUCTION_ADDRESS: +56b3952f04ebde68 748bc9f1 654c dec esp NTGLOBALFLAG: 0 APPLICATION_VERIFIER_FLAGS: 0 FAULTING_THREAD: 00001560 BUGCHECK_STR: APPLICATION_FAULT_SOFTWARE_NX_FAULT_NULL PRIMARY_PROBLEM_CLASS: SOFTWARE_NX_FAULT_NULL DEFAULT_BUCKET_ID: SOFTWARE_NX_FAULT_NULL LAST_CONTROL_TRANSFER: from 5c704fa8 to 00000000 STACK_TEXT: WARNING: Frame IP not in any known module. Following frames may be wrong. 0f61f74c 5c704fa8 1b17a134 193b8e08 0e690e14 0x0 0f61f76c 5c712360 0e690e14 1b17a134 0e690e14 agcore!CFrameworkElement::SetValue+0x1d7 0f61f788 5c7123a8 0e690e14 1b17a134 0e690e14 agcore!CShape::SetValue+0x72 0f61f7a0 5c70a6ff 0e690e14 1b17a134 00000000 agcore!CEllipse::SetValue+0x3b 0f61f7d0 5c752c2b 1b17a090 193b8e08 00000000 agcore!CAnimation::DoSetValue+0x50 0f61f810 5c7a7fb1 0f61f884 0f61f868 1b17a090 agcore!CAnimation::UpdateAnimationUsingKeyFrames+0x3b5 0f61f82c 5c707146 00000000 00000000 00000000 agcore!CAnimation::UpdateAnimation+0x184 0f61f87c 5c7071e5 3e4c8000 0f61f8cc 00000000 agcore!CTimeline::ComputeState+0x13a 0f61f89c 5c706d49 193f82b0 0f61f8cc 0f61f8d4 agcore!CTimelineGroup::ComputeState+0x8c 0f61f8ac 5c7069c7 3e4c8000 0f61f8cc 0b111f60 agcore!CStoryboard::ComputeState+0x48 0f61f8d4 5c706a29 0e6a0ca0 00000000 0e490070 agcore!CTimeManager::Tick+0x79 0f61f8e8 5c78f960 0b0e6d68 0f61f990 00000000 agcore!CCoreServices::Tick+0x21 0f61f940 5c706ac2 0b111f60 0e42ca08 ffffffff agcore!CCoreServices::Draw+0x140 0f61f964 67ac141c 0af99b90 00000000 0f61f990 agcore!CCoreServices::Draw+0x2d 0f61f9b4 67a933c2 0f61f9c8 00000000 00000000 npctrl!CXcpBrowserHost::OnTick+0x1b1 0f61f9e0 67a927c6 0064069c 00000402 00000000 npctrl!CXcpDispatcher::Tick+0xf3 0f61fa08 67a92709 0064069c 00000402 00000000 npctrl!CXcpDispatcher::OnReentrancyProtectedWindowMessage+0xcd 0f61fa28 764b6238 0064069c 00000402 00000000 npctrl!CXcpDispatcher::WindowProc+0xb8 0f61fa54 764b68ea 67a9269d 0064069c 00000402 user32!InternalCallWinProc+0x23 0f61facc 764b7d31 00000000 67a9269d 0064069c user32!UserCallWinProcCheckWow+0x109 0f61fb2c 764b7dfa 67a9269d 00000000 0f61fbb4 user32!DispatchMessageWorker+0x3bc 0f61fb3c 6fe504a6 0f61fb54 00000000 0ab11908 user32!DispatchMessageW+0xf 0f61fbb4 6fe60446 0af956a0 00000000 0b18a338 ieframe!CTabWindow::_TabWindowThreadProc+0x452 0f61fc6c 769d49bd 0ab11908 00000000 0f61fc88 ieframe!LCIETab_ThreadProc+0x2c1 0f61fc7c 76e53677 0b18a338 0f61fcc8 77829d72 iertutil!CIsoScope::RegisterThread+0xab 0f61fc88 77829d72 0b18a338 7dbc895d 00000000 kernel32!BaseThreadInitThunk+0xe 0f61fcc8 77829d45 769d49af 0b18a338 00000000 ntdll!__RtlUserThreadStart+0x70 0f61fce0 00000000 769d49af 0b18a338 00000000 ntdll!_RtlUserThreadStart+0x1b SYMBOL_STACK_INDEX: 1 SYMBOL_NAME: agcore!CFrameworkElement::SetValue+1d7 FOLLOWUP_NAME: MachineOwner MODULE_NAME: agcore IMAGE_NAME: agcore.dll DEBUG_FLR_IMAGE_TIMESTAMP: 4a67e422 STACK_COMMAND: ~44s; .ecxr ; kb FAILURE_BUCKET_ID: SOFTWARE_NX_FAULT_NULL_c0000005_agcore.dll!CFrameworkElement::SetValue BUCKET_ID: APPLICATION_FAULT_SOFTWARE_NX_FAULT_NULL_BAD_IP_agcore!CFrameworkElement::SetValue+1d7

  Read the article

• How to debug EXC_BAD_ACCESS that occurs only on release target for an iPhone app?

  - by Bobby Moretti

  I'm developing an iPhone application. I have an EXC_BAD_ACCESS that occurs only in the release target; when I build the debug target the exception does not occur. However, when I set the NSZombieEnabled environment variable to YES, I still get the EXC_BAD_ACCESS with no further information. Is it even possible for NSZombieEnabled to work when executing the release target? I don't see why not, since gdb is running in both cases... Update: here is a printout of the top of the stack: #0 0x33369ebc in objc_msgSend () #1 0x3144f968 in -[EAInputStream _streamEventTrigger] () #2 0x3144fe78 in __streamEventTrigger () #3 0x338ae3a6 in CFRunLoopRunSpecific () #4 0x338adc1e in CFRunLoopRunInMode () #5 0x32ed6966 in -[NSRunLoop(NSRunLoop) runMode:beforeDate:] () #6 0x00005b06 in -[IOStreamDelegate removeMsg:] (self=0x142cc0, _cmd=<value temporarily unavailable, due to optimizations>, message=0x2fffe544) at /Users/robertmoretti/Documents/XXXXXXX/IOStreamDelegate.m:191 Here is a gdb session from inside the objc_msgSend call at the top: (gdb) p/x $r0 $6 = 0x3100000 (gdb) x/s $r1 0x32d7cff8: "release" (gdb) disassemble $pc Dump of assembler code for function objc_msgSend: 0x33369ea8 <objc_msgSend+0>: teq r0, #0 ; 0x0 0x33369eac <objc_msgSend+4>: moveq r1, #0 ; 0x0 0x33369eb0 <objc_msgSend+8>: bxeq lr 0x33369eb4 <objc_msgSend+12>: push {r3, r4, r5, r6} 0x33369eb8 <objc_msgSend+16>: ldr r4, [r0] 0x33369ebc <objc_msgSend+20>: ldr r5, [r4, #8] 0x33369ec0 <objc_msgSend+24>: ldr r6, [r5] 0x33369ec4 <objc_msgSend+28>: add r3, r5, #8 ; 0x8 0x33369ec8 <objc_msgSend+32>: and r5, r6, r1, lsr #2 0x33369ecc <objc_msgSend+36>: ldr r4, [r3, r5, lsl #2] 0x33369ed0 <objc_msgSend+40>: teq r4, #0 ; 0x0 0x33369ed4 <objc_msgSend+44>: add r5, r5, #1 ; 0x1 0x33369ed8 <objc_msgSend+48>: beq 0x33369efc <objc_msgSend+84> 0x33369edc <objc_msgSend+52>: ldr r12, [r4] 0x33369ee0 <objc_msgSend+56>: teq r1, r12 0x33369ee4 <objc_msgSend+60>: and r5, r5, r6 0x33369ee8 <objc_msgSend+64>: bne 0x33369ecc <objc_msgSend+36> 0x33369eec <objc_msgSend+68>: ldr r12, [r4, #8] 0x33369ef0 <objc_msgSend+72>: teq r4, r4 0x33369ef4 <objc_msgSend+76>: pop {r3, r4, r5, r6} 0x33369ef8 <objc_msgSend+80>: bx r12 0x33369efc <objc_msgSend+84>: pop {r3, r4, r5, r6} 0x33369f00 <objc_msgSend+88>: b 0x33369f04 <objc_msgSend_uncached> End of assembler dump. (gdb) p/x *$r0 $9 = 0x0 The exception occurs on the line 0x33369ebc <objc_msgSend+20>: ldr r5, [r4, #8]. r4 has just been given the value pointed to by r0, which happens to be 0. I am wondering what is supposed to be in the memory region of 0x3100000. Here's a memory dump of that area: (gdb) x/256w 0x3100000 0x3100000: 0x00000000 0x0000a293 0xaa650505 0x00000000 0x3100010: 0x0000a294 0xaa670505 0x00000000 0x0000a295 0x3100020: 0xaa690505 0x00000000 0x0000a296 0xaa6b0505 0x3100030: 0x00000000 0x0000a297 0xaa6d0505 0x00000000 0x3100040: 0x0000a298 0xaa6f0505 0x00000000 0x0000a299 0x3100050: 0xaa710505 0x00000000 0x0000a29a 0xaa730505 0x3100060: 0x00000000 0x0000a29b 0xaa750505 0x00000000 0x3100070: 0x0000a29c 0xaa770505 0x00000000 0x0000a29d 0x3100080: 0xaa790505 0x00000000 0x0000a29e 0xaa7b0505 0x3100090: 0x00000000 0x0000a29f 0xaa7d0505 0x00000000 0x31000a0: 0x0000a2a0 0xaa7f0505 0x00000000 0x0000a2a1 0x31000b0: 0xaa810505 0x00000000 0x0000a2a2 0xaa830505 0x31000c0: 0x00000000 0x0000a2a3 0xaa850505 0x00000000 0x31000d0: 0x0000a2a4 0xaa870505 0x00000000 0x0000a2a5 0x31000e0: 0xaa890505 0x00000000 0x0000a2a6 0xaa8b0505 0x31000f0: 0x00000000 0x0000a2a7 0xaa8d0505 0x00000000 0x3100100: 0x0000a2a8 0xaa8f0505 0x00000000 0x0000a2a9 0x3100110: 0xaa910505 0x00000000 0x0000a2aa 0xaa930505 0x3100120: 0x00000000 0x0000a2ab 0xaa950505 0x00000000 0x3100130: 0x0000a2ac 0xaa970505 0x00000000 0x0000a2ad 0x3100140: 0xaa990505 0x00000000 0x0000a2ae 0xaa9b0505 0x3100150: 0x00000000 0x0000a2af 0xaa9d0505 0x00000000 0x3100160: 0x0000a2b0 0xaa9f0505 0x00000000 0x0000a2b1 0x3100170: 0xaaa10505 0x00000000 0x0000a2b2 0xaaa30505 0x3100180: 0x00000000 0x0000a2b3 0xaaa50505 0x00000000 0x3100190: 0x0000a2b4 0xaaa70505 0x00000000 0x0000a2b5 0x31001a0: 0xaaa90505 0x00000000 0x0000a2b6 0xaaab0505 0x31001b0: 0x00000000 0x0000a2b7 0xaaad0505 0x00000000 0x31001c0: 0x0000a2b8 0xaaaf0505 0x00000000 0x0000a2b9 0x31001d0: 0xaab10505 0x00000000 0x0000a2ba 0xaab30505 0x31001e0: 0x00000000 0x0000a2bb 0xaab50505 0x00000000 0x31001f0: 0x0000a2bc 0xaab70505 0x00000000 0x0000a2bd 0x3100200: 0xaab90505 0x00000000 0x0000a2be 0xaabb0505 0x3100210: 0x00000000 0x0000a2bf 0xaabd0505 0x00000000 0x3100220: 0x0000a2c0 0xaabf0505 0x00000000 0x0000a2c1 0x3100230: 0xaac10505 0x00000000 0x0000a2c2 0xaac30505 0x3100240: 0x00000000 0x0000a2c3 0xaac50505 0x00000000 0x3100250: 0x0000a2c4 0xaac70505 0x00000000 0x0000a2c5 0x3100260: 0xaac90505 0x00000000 0x0000a2c6 0xaacb0505 0x3100270: 0x00000000 0x0000a2c7 0xaacd0505 0x00000000 0x3100280: 0x0000a2c8 0xaacf0505 0x00000000 0x0000a2c9 0x3100290: 0xaad10505 0x00000000 0x0000a2ca 0xaad30505 0x31002a0: 0x00000000 0x0000a2cb 0xaad50505 0x00000000 0x31002b0: 0x0000a2cc 0xaad70505 0x00000000 0x0000a2cd 0x31002c0: 0xaad90505 0x00000000 0x0000a2ce 0xaadb0505 0x31002d0: 0x00000000 0x0000a2cf 0xaadd0505 0x00000000 0x31002e0: 0x0000a2d0 0xaadf0505 0x00000000 0x0000a2d1 0x31002f0: 0xaae10505 0x00000000 0x0000a2d2 0xaae30505 0x3100300: 0x00000000 0x0000a2d3 0xaae50505 0x00000000 0x3100310: 0x0000a2d4 0xaae70505 0x00000000 0x0000a2d5 0x3100320: 0xaae90505 0x00000000 0x0000a2d6 0xaaeb0505 0x3100330: 0x00000000 0x0000a2d7 0xaaed0505 0x00000000 0x3100340: 0x0000a2d8 0xaaef0505 0x00000000 0x0000a2d9 0x3100350: 0xaaf10505 0x00000000 0x0000a2da 0xaaf30505 0x3100360: 0x00000000 0x0000a2db 0xaaf50505 0x00000000 0x3100370: 0x0000a2dc 0xaaf70505 0x00000000 0x0000a2dd 0x3100380: 0xaaf90505 0x00000000 0x0000a2de 0xaafb0505 0x3100390: 0x00000000 0x0000a2df 0xaafd0505 0x00000000 0x31003a0: 0x0000a2e0 0xab050505 0x00000000 0x0000a2e1 0x31003b0: 0xab070505 0x00000000 0x0000a2e2 0xab090505 0x31003c0: 0x00000000 0x0000a2e3 0xab0b0505 0x00000000 0x31003d0: 0x0000a2e4 0xab0d0505 0x00000000 0x0000a2e5 0x31003e0: 0xab0f0505 0x00000000 0x0000a2e6 0xab110505 0x31003f0: 0x00000000 0x0000a2e7 0xab130505 0x00000000 I don't really know what else to try; hopefully someone with more iphone experience will be able to recognize this memory as something meaningful.

  Read the article

• Debugging EXC_BAD_ACCESS that occurs only on release target for an iPhone app?

  - by Bobby Moretti

  I'm developing an iPhone application. I have an EXC_BAD_ACCESS that occurs only in the release target; when I build the debug target the exception does not occur. However, when I set the NSZombieEnabled environment variable to YES, I still get the EXC_BAD_ACCESS with no further information. Is it even possible for NSZombieEnabled to work when executing the release target? I don't see why not, since gdb is running in both cases... Update: here is a printout of the top of the stack: #0 0x33369ebc in objc_msgSend () #1 0x3144f968 in -[EAInputStream _streamEventTrigger] () #2 0x3144fe78 in __streamEventTrigger () #3 0x338ae3a6 in CFRunLoopRunSpecific () #4 0x338adc1e in CFRunLoopRunInMode () #5 0x32ed6966 in -[NSRunLoop(NSRunLoop) runMode:beforeDate:] () #6 0x00005b06 in -[IOStreamDelegate removeMsg:] (self=0x142cc0, _cmd=<value temporarily unavailable, due to optimizations>, message=0x2fffe544) at /Users/robertmoretti/Documents/XXXXXXX/IOStreamDelegate.m:191 Here is a gdb session from inside the objc_msgSend call at the top: (gdb) p/x $r0 $6 = 0x3100000 (gdb) x/s $r1 0x32d7cff8: "release" (gdb) disassemble $pc Dump of assembler code for function objc_msgSend: 0x33369ea8 <objc_msgSend+0>: teq r0, #0 ; 0x0 0x33369eac <objc_msgSend+4>: moveq r1, #0 ; 0x0 0x33369eb0 <objc_msgSend+8>: bxeq lr 0x33369eb4 <objc_msgSend+12>: push {r3, r4, r5, r6} 0x33369eb8 <objc_msgSend+16>: ldr r4, [r0] 0x33369ebc <objc_msgSend+20>: ldr r5, [r4, #8] 0x33369ec0 <objc_msgSend+24>: ldr r6, [r5] 0x33369ec4 <objc_msgSend+28>: add r3, r5, #8 ; 0x8 0x33369ec8 <objc_msgSend+32>: and r5, r6, r1, lsr #2 0x33369ecc <objc_msgSend+36>: ldr r4, [r3, r5, lsl #2] 0x33369ed0 <objc_msgSend+40>: teq r4, #0 ; 0x0 0x33369ed4 <objc_msgSend+44>: add r5, r5, #1 ; 0x1 0x33369ed8 <objc_msgSend+48>: beq 0x33369efc <objc_msgSend+84> 0x33369edc <objc_msgSend+52>: ldr r12, [r4] 0x33369ee0 <objc_msgSend+56>: teq r1, r12 0x33369ee4 <objc_msgSend+60>: and r5, r5, r6 0x33369ee8 <objc_msgSend+64>: bne 0x33369ecc <objc_msgSend+36> 0x33369eec <objc_msgSend+68>: ldr r12, [r4, #8] 0x33369ef0 <objc_msgSend+72>: teq r4, r4 0x33369ef4 <objc_msgSend+76>: pop {r3, r4, r5, r6} 0x33369ef8 <objc_msgSend+80>: bx r12 0x33369efc <objc_msgSend+84>: pop {r3, r4, r5, r6} 0x33369f00 <objc_msgSend+88>: b 0x33369f04 <objc_msgSend_uncached> End of assembler dump. (gdb) p/x *$r0 $9 = 0x0 The exception occurs on the line 0x33369ebc <objc_msgSend+20>: ldr r5, [r4, #8]. r4 has just been given the value pointed to by r0, which happens to be 0. I am wondering what is supposed to be in the memory region of 0x3100000. Here's a memory dump of that area: (gdb) x/256w 0x3100000 0x3100000: 0x00000000 0x0000a293 0xaa650505 0x00000000 0x3100010: 0x0000a294 0xaa670505 0x00000000 0x0000a295 0x3100020: 0xaa690505 0x00000000 0x0000a296 0xaa6b0505 0x3100030: 0x00000000 0x0000a297 0xaa6d0505 0x00000000 0x3100040: 0x0000a298 0xaa6f0505 0x00000000 0x0000a299 0x3100050: 0xaa710505 0x00000000 0x0000a29a 0xaa730505 0x3100060: 0x00000000 0x0000a29b 0xaa750505 0x00000000 0x3100070: 0x0000a29c 0xaa770505 0x00000000 0x0000a29d 0x3100080: 0xaa790505 0x00000000 0x0000a29e 0xaa7b0505 0x3100090: 0x00000000 0x0000a29f 0xaa7d0505 0x00000000 0x31000a0: 0x0000a2a0 0xaa7f0505 0x00000000 0x0000a2a1 0x31000b0: 0xaa810505 0x00000000 0x0000a2a2 0xaa830505 0x31000c0: 0x00000000 0x0000a2a3 0xaa850505 0x00000000 0x31000d0: 0x0000a2a4 0xaa870505 0x00000000 0x0000a2a5 0x31000e0: 0xaa890505 0x00000000 0x0000a2a6 0xaa8b0505 0x31000f0: 0x00000000 0x0000a2a7 0xaa8d0505 0x00000000 0x3100100: 0x0000a2a8 0xaa8f0505 0x00000000 0x0000a2a9 0x3100110: 0xaa910505 0x00000000 0x0000a2aa 0xaa930505 0x3100120: 0x00000000 0x0000a2ab 0xaa950505 0x00000000 0x3100130: 0x0000a2ac 0xaa970505 0x00000000 0x0000a2ad 0x3100140: 0xaa990505 0x00000000 0x0000a2ae 0xaa9b0505 0x3100150: 0x00000000 0x0000a2af 0xaa9d0505 0x00000000 0x3100160: 0x0000a2b0 0xaa9f0505 0x00000000 0x0000a2b1 0x3100170: 0xaaa10505 0x00000000 0x0000a2b2 0xaaa30505 0x3100180: 0x00000000 0x0000a2b3 0xaaa50505 0x00000000 0x3100190: 0x0000a2b4 0xaaa70505 0x00000000 0x0000a2b5 0x31001a0: 0xaaa90505 0x00000000 0x0000a2b6 0xaaab0505 0x31001b0: 0x00000000 0x0000a2b7 0xaaad0505 0x00000000 0x31001c0: 0x0000a2b8 0xaaaf0505 0x00000000 0x0000a2b9 0x31001d0: 0xaab10505 0x00000000 0x0000a2ba 0xaab30505 0x31001e0: 0x00000000 0x0000a2bb 0xaab50505 0x00000000 0x31001f0: 0x0000a2bc 0xaab70505 0x00000000 0x0000a2bd 0x3100200: 0xaab90505 0x00000000 0x0000a2be 0xaabb0505 0x3100210: 0x00000000 0x0000a2bf 0xaabd0505 0x00000000 0x3100220: 0x0000a2c0 0xaabf0505 0x00000000 0x0000a2c1 0x3100230: 0xaac10505 0x00000000 0x0000a2c2 0xaac30505 0x3100240: 0x00000000 0x0000a2c3 0xaac50505 0x00000000 0x3100250: 0x0000a2c4 0xaac70505 0x00000000 0x0000a2c5 0x3100260: 0xaac90505 0x00000000 0x0000a2c6 0xaacb0505 0x3100270: 0x00000000 0x0000a2c7 0xaacd0505 0x00000000 0x3100280: 0x0000a2c8 0xaacf0505 0x00000000 0x0000a2c9 0x3100290: 0xaad10505 0x00000000 0x0000a2ca 0xaad30505 0x31002a0: 0x00000000 0x0000a2cb 0xaad50505 0x00000000 0x31002b0: 0x0000a2cc 0xaad70505 0x00000000 0x0000a2cd 0x31002c0: 0xaad90505 0x00000000 0x0000a2ce 0xaadb0505 0x31002d0: 0x00000000 0x0000a2cf 0xaadd0505 0x00000000 0x31002e0: 0x0000a2d0 0xaadf0505 0x00000000 0x0000a2d1 0x31002f0: 0xaae10505 0x00000000 0x0000a2d2 0xaae30505 0x3100300: 0x00000000 0x0000a2d3 0xaae50505 0x00000000 0x3100310: 0x0000a2d4 0xaae70505 0x00000000 0x0000a2d5 0x3100320: 0xaae90505 0x00000000 0x0000a2d6 0xaaeb0505 0x3100330: 0x00000000 0x0000a2d7 0xaaed0505 0x00000000 0x3100340: 0x0000a2d8 0xaaef0505 0x00000000 0x0000a2d9 0x3100350: 0xaaf10505 0x00000000 0x0000a2da 0xaaf30505 0x3100360: 0x00000000 0x0000a2db 0xaaf50505 0x00000000 0x3100370: 0x0000a2dc 0xaaf70505 0x00000000 0x0000a2dd 0x3100380: 0xaaf90505 0x00000000 0x0000a2de 0xaafb0505 0x3100390: 0x00000000 0x0000a2df 0xaafd0505 0x00000000 0x31003a0: 0x0000a2e0 0xab050505 0x00000000 0x0000a2e1 0x31003b0: 0xab070505 0x00000000 0x0000a2e2 0xab090505 0x31003c0: 0x00000000 0x0000a2e3 0xab0b0505 0x00000000 0x31003d0: 0x0000a2e4 0xab0d0505 0x00000000 0x0000a2e5 0x31003e0: 0xab0f0505 0x00000000 0x0000a2e6 0xab110505 0x31003f0: 0x00000000 0x0000a2e7 0xab130505 0x00000000 I don't really know what else to try; hopefully someone with more iphone experience will be able to recognize this memory as something meaningful.

  Read the article

• Fastest pathfinding for static node matrix

  - by Sean Martin

  I'm programming a route finding routine in VB.NET for an online game I play, and I'm searching for the fastest route finding algorithm for my map type. The game takes place in space, with thousands of solar systems connected by jump gates. The game devs have provided a DB dump containing a list of every system and the systems it can jump to. The map isn't quite a node tree, since some branches can jump to other branches - more of a matrix. What I need is a fast pathfinding algorithm. I have already implemented an A* routine and a Dijkstra's, both find the best path but are too slow for my purposes - a search that considers about 5000 nodes takes over 20 seconds to compute. A similar program on a website can do the same search in less than a second. This website claims to use D*, which I have looked into. That algorithm seems more appropriate for dynamic maps rather than one that does not change - unless I misunderstand it's premise. So is there something faster I can use for a map that is not your typical tile/polygon base? GBFS? Perhaps a DFS? Or have I likely got some problem with my A* - maybe poorly chosen heuristics or movement cost? Currently my movement cost is the length of the jump (the DB dump has solar system coordinates as well), and the heuristic is a quick euclidean calculation from the node to the goal. In case anyone has some optimizations for my A*, here is the routine that consumes about 60% of my processing time, according to my profiler. The coordinateData table contains a list of every system's coordinates, and neighborNode.distance is the distance of the jump. Private Function findDistance(ByVal startSystem As Integer, ByVal endSystem As Integer) As Integer 'hCount += 1 'If hCount Mod 0 = 0 Then 'Return hCache 'End If 'Initialize variables to be filled Dim x1, x2, y1, y2, z1, z2 As Integer 'LINQ queries for solar system data Dim systemFromData = From result In jumpDataDB.coordinateDatas Where result.systemId = startSystem Select result.x, result.y, result.z Dim systemToData = From result In jumpDataDB.coordinateDatas Where result.systemId = endSystem Select result.x, result.y, result.z 'LINQ execute 'Fill variables with solar system data for from and to system For Each solarSystem In systemFromData x1 = (solarSystem.x) y1 = (solarSystem.y) z1 = (solarSystem.z) Next For Each solarSystem In systemToData x2 = (solarSystem.x) y2 = (solarSystem.y) z2 = (solarSystem.z) Next Dim x3 = Math.Abs(x1 - x2) Dim y3 = Math.Abs(y1 - y2) Dim z3 = Math.Abs(z1 - z2) 'Calculate distance and round 'Dim distance = Math.Round(Math.Sqrt(Math.Abs((x1 - x2) ^ 2) + Math.Abs((y1 - y2) ^ 2) + Math.Abs((z1 - z2) ^ 2))) Dim distance = firstConstant * Math.Min(secondConstant * (x3 + y3 + z3), Math.Max(x3, Math.Max(y3, z3))) 'Dim distance = Math.Abs(x1 - x2) + Math.Abs(z1 - z2) + Math.Abs(y1 - y2) 'hCache = distance Return distance End Function And the main loop, the other 30% 'Begin search While openList.Count() != 0 'Set current system and move node to closed currentNode = lowestF() move(currentNode.id) For Each neighborNode In neighborNodes If Not onList(neighborNode.toSystem, 0) Then If Not onList(neighborNode.toSystem, 1) Then Dim newNode As New nodeData() newNode.id = neighborNode.toSystem newNode.parent = currentNode.id newNode.g = currentNode.g + neighborNode.distance newNode.h = findDistance(newNode.id, endSystem) newNode.f = newNode.g + newNode.h newNode.security = neighborNode.security openList.Add(newNode) shortOpenList(OLindex) = newNode.id OLindex += 1 Else Dim proposedG As Integer = currentNode.g + neighborNode.distance If proposedG < gValue(neighborNode.toSystem) Then changeParent(neighborNode.toSystem, currentNode.id, proposedG) End If End If End If Next 'Check to see if done If currentNode.id = endSystem Then Exit While End If End While If clarification is needed on my spaghetti code, I'll try to explain.

  Read the article

• How would you gather client's data on Google App Engine without using Datastore/Backend Instances too much?

  - by ruslan

  I'm relatively new to StackExchange and not sure if it's appropriate place to ask design question. Site gives me a hint "The question you're asking appears subjective and is likely to be closed". Please let me know. Anyway.. One of the projects I'm working on is online survey engine. It's my first big commercial project on Google App Engine. I need your advice on how to collect stats and efficiently record them in DataStore without bankrupting me. Initial requirements are: After user finishes survey client sends list of pairs [ID (int) + PercentHit (double)]. This list shows how close answers of this user match predefined answers of reference answerers (which identified by IDs). I call them "target IDs". Creator of the survey wants to see aggregated % for given IDs for last hour, particular timeframe or from the beginning of the survey. Some surveys may have thousands of target/reference answerers. So I created entity public class HitsStatsDO implements Serializable { @Id transient private Long id; transient private Long version = (long) 0; transient private Long startDate; @Parent transient private Key parent; // fake parent which contains target id @Transient int targetId; private double avgPercent; private long hitCount; } But writing HitsStatsDO for each target from each user would give a lot of data. For instance I had a survey with 3000 targets which was answered by ~4 million people within one week with 300K people taking survey in first day. Even if we assume they were answering it evenly for 24 hours it would give us ~1040 writes/second. Obviously it hits concurrent writes limit of Datastore. I decided I'll collect data for one hour and save that, that's why there are avgPercent and hitCount in HitsStatsDO. GAE instances are stateless so I had to use dynamic backend instance. There I have something like this: // Contains stats for one hour private class Shard { ReadWriteLock lock = new ReentrantReadWriteLock(); Map<Integer, HitsStatsDO> map = new HashMap<Integer, HitsStatsDO>(); // Key is target ID public void saveToDatastore(); public void updateStats(Long startDate, Map<Integer, Double> hits); } and map with shard for current hour and previous hour (which doesn't stay here for long) private HashMap<Long, Shard> shards = new HashMap<Long, Shard>(); // Key is HitsStatsDO.startDate So once per hour I dump Shard for previous hour to Datastore. Plus I have class LifetimeStats which keeps Map<Integer, HitsStatsDO> in memcached where map-key is target ID. Also in my backend shutdown hook method I dump stats for unfinished hour to Datastore. There is only one major issue here - I have only ONE backend instance :) It raises following questions on which I'd like to hear your opinion: Can I do this without using backend instance ? What if one instance is not enough ? How can I split data between multiple dynamic backend instances? It hard because I don't know how many I have because Google creates new one as load increases. I know I can launch exact number of resident backend instances. But how many ? 2, 5, 10 ? What if I have no load at all for a week. Constantly running 10 backend instances is too expensive. What do I do with data from clients while backend instance is dead/restarting? Thank you very much in advance for your thoughts.

  Read the article

• How can I gather client's data on Google App Engine without using Datastore/Backend Instances too much?

  - by ruslan

  One of the projects I'm working on is online survey engine. It's my first big commercial project on Google App Engine. I need your advice on how to collect stats and efficiently record them in DataStore without bankrupting me. Initial requirements are: After user finishes survey client sends list of pairs [ID (int) + PercentHit (double)]. This list shows how close answers of this user match predefined answers of reference answerers (which identified by IDs). I call them "target IDs". Creator of the survey wants to see aggregated % for given IDs for last hour, particular timeframe or from the beginning of the survey. Some surveys may have thousands of target/reference answerers. So I created entity public class HitsStatsDO implements Serializable { @Id transient private Long id; transient private Long version = (long) 0; transient private Long startDate; @Parent transient private Key parent; // fake parent which contains target id @Transient int targetId; private double avgPercent; private long hitCount; } But writing HitsStatsDO for each target from each user would give a lot of data. For instance I had a survey with 3000 targets which was answered by ~4 million people within one week with 300K people taking survey in first day. Even if we assume they were answering it evenly for 24 hours it would give us ~1040 writes/second. Obviously it hits concurrent writes limit of Datastore. I decided I'll collect data for one hour and save that, that's why there are avgPercent and hitCount in HitsStatsDO. GAE instances are stateless so I had to use dynamic backend instance. There I have something like this: // Contains stats for one hour private class Shard { ReadWriteLock lock = new ReentrantReadWriteLock(); Map<Integer, HitsStatsDO> map = new HashMap<Integer, HitsStatsDO>(); // Key is target ID public void saveToDatastore(); public void updateStats(Long startDate, Map<Integer, Double> hits); } and map with shard for current hour and previous hour (which doesn't stay here for long) private HashMap<Long, Shard> shards = new HashMap<Long, Shard>(); // Key is HitsStatsDO.startDate So once per hour I dump Shard for previous hour to Datastore. Plus I have class LifetimeStats which keeps Map<Integer, HitsStatsDO> in memcached where map-key is target ID. Also in my backend shutdown hook method I dump stats for unfinished hour to Datastore. There is only one major issue here - I have only ONE backend instance :) It raises following questions on which I'd like to hear your opinion: Can I do this without using backend instance ? What if one instance is not enough ? How can I split data between multiple dynamic backend instances? It hard because I don't know how many I have because Google creates new one as load increases. I know I can launch exact number of resident backend instances. But how many ? 2, 5, 10 ? What if I have no load at all for a week. Constantly running 10 backend instances is too expensive. What do I do with data from clients while backend instance is dead/restarting?

  Read the article

• How do I install LFE on Ubuntu Karmic?

  - by karlthorwald

  Erlang was already installed: $dpkg -l|grep erlang ii erlang 1:13.b.3-dfsg-2ubuntu2 Concurrent, real-time, distributed function ii erlang-appmon 1:13.b.3-dfsg-2ubuntu2 Erlang/OTP application monitor ii erlang-asn1 1:13.b.3-dfsg-2ubuntu2 Erlang/OTP modules for ASN.1 support ii erlang-base 1:13.b.3-dfsg-2ubuntu2 Erlang/OTP virtual machine and base applica ii erlang-common-test 1:13.b.3-dfsg-2ubuntu2 Erlang/OTP application for automated testin ii erlang-debugger 1:13.b.3-dfsg-2ubuntu2 Erlang/OTP application for debugging and te ii erlang-dev 1:13.b.3-dfsg-2ubuntu2 Erlang/OTP development libraries and header [... many more] Erlang seems to work: $ erl Erlang R13B03 (erts-5.7.4) [source] [64-bit] [smp:2:2] [rq:2] [async-threads:0] [hipe] [kernel-poll:false] Eshell V5.7.4 (abort with ^G) 1> I downloaded lfe from github and checked out 0.5.2: git clone http://github.com/rvirding/lfe.git cd lfe git checkout -b local0.5.2 e207eb2cad $ configure configure: command not found $ make mkdir -p ebin erlc -I include -o ebin -W0 -Ddebug +debug_info src/*.erl #erl -I -pa ebin -noshell -eval -noshell -run edoc file src/leex.erl -run init stop #erl -I -pa ebin -noshell -eval -noshell -run edoc_run application "'Leex'" '"."' '[no_packages]' #mv src/*.html doc/ Must be something stupid i missed :o $ sudo make install make: *** No rule to make target `install'. Stop. $ erl -noshell -noinput -s lfe_boot start {"init terminating in do_boot",{undef,[{lfe_boot,start,[]},{init,start_it,1},{init,start_em,1}]}} Crash dump was written to: erl_crash.dump init terminating in do_boot () Is there an example how I would create a hello world source file and compile and run it?

  Read the article

• How to change TestNG dataProvider order

  - by momad

  Hi, I am running hundreds of tests against a large publishing system and would like to paralellize the tests using TestNG. However, I cannot find any easy way of doing this. Each test case instanciates an instance of this publisher, send some messages, wait for those messages to be published, then dump out the contents of the publish queues and compare against expected outcome. Doing this with so many tests (even if I paralellize using threads, still takes a very long time to complete (1 day or more)). We've found that in testing this sort of system, it's best to start up system once, run all tests to send their messages, wait for publish to do its thing, dump all outputs, and match outputs with tests and verify. For example, instead of the following: @Test public void testRule1() { Publisher pub = new Publisher(); pub.sendRule(new Rule("test1-a")); sleep(10); // wait 10 seconds pub.dumpRules(); verifyRule("test1-a"); } We wanted to do something like the following: @Test public void testRule1(bool sendMode) { if(sendMode) { this.pub.sendRule(new Rule("test1-a")); } else { verifyRule("test1-a"); } } Where you have a dataProvider run through all the tests with sendMode = true and then perform dumpAllRules() followed by running through all of the tests again with sendMode = false. The problem is, TestNG calls the same method twice, once with sendMode = true followed by sendMode = false. Is there anyway to accomplish this in TestNG? Thanks!

  Read the article

• Rails - difference between config.cache_store and config.action_controller.cache_store?

  - by gsmendoza

  If I set this in my environment config.action_controller.cache_store = :mem_cache_store ActionController::Base.cache_store will use a memcached store but Rails.cache will use a memory store instead: $ ./script/console >> ActionController::Base.cache_store => #<ActiveSupport::Cache::MemCacheStore:0xb6eb4bbc @data=<MemCache: 1 servers, ns: nil, ro: false>> >> Rails.cache => #<ActiveSupport::Cache::MemoryStore:0xb78b5e54 @data={}> In my app, I use Rails.cache.fetch(key){ object } to cache objects inside my helpers. All this time, I assumed that Rails.cache uses the memcached store so I'm surprised that it uses memory store. If I change the cache_store setting in my environment to config.cache_store = :mem_cache_store both ActionController::Base.cache_store and Rails.cache will now use the same memory store, which is what I expect: $ ./script/console >> ActionController::Base.cache_store => #<ActiveSupport::Cache::MemCacheStore:0xb7b8e928 @data=<MemCache: 1 servers, ns: nil, ro: false>, @middleware=#<Class:0xb7b73d44>, @thread_local_key=:active_support_cache_mem_cache_store_local_cache> >> Rails.cache => #<ActiveSupport::Cache::MemCacheStore:0xb7b8e928 @data=<MemCache: 1 servers, ns: nil, ro: false>, @middleware=#<Class:0xb7b73d44>, @thread_local_key=:active_support_cache_mem_cache_store_local_cache> However, when I run the app, I get a "marshal dump" error in the line where I call Rails.cache.fetch(key){ object } no marshal_dump is defined for class Proc Extracted source (around line #1): 1: Rails.cache.fetch(fragment_cache_key(...), :expires_in => 15.minutes) { ... } vendor/gems/memcache-client-1.8.1/lib/memcache.rb:359:in 'dump' vendor/gems/memcache-client-1.8.1/lib/memcache.rb:359:in 'set_without_newrelic_trace' What gives? Is Rails.cache meant to be a memory store? Should I call controller.cache_store.fetch in the places where I call Rails.cache.fetch?

  Read the article

• How to keep character encoding with database queries.

  - by JasonS

  Hi, I am doing the following. 1) I am exporting a database and saving it to a file called dump.sql. 2) The file is then transferred to a different server via PHP ftp. 3) When the file has been successfully transferred the administrator has an option to run a 'dbtransfer' script on the new host. 4) This script blows up the script and runs the queries line by line. This works great - however there is a problem with foreign language encoding. We are using UTF-8. Step 1 : This works fine, file is in UTF-8 Format. Step 3 : When I test the contents of the dump.sql file using mb_check_encoding(). The string comes back as UTF-8. Step 4 : This creates tables with utf8_general_ci encoding. The information is dumped in. When I check the table after the transfer I get records like this: 'ç,Ç,ö,Ö,ü,Ü,ı,İ,ş,Ş,ğ,Ğ'. I don't understand how a UTF-8 string can lose its encoding when it goes into the database. Am I missing a step? Do I need to run some sort of function to ensure the string is parsed as UTF-8? Once the system is installed I can save foreign language queries. It is just the transfer that is messing up. Any ideas?

  Read the article

• Firefox extension is freezing Firefox until request is completed

  - by Michael

  For some reason the function is freezing along with firefox until it fully retrieve the stream from requested site. Is there any mechanism to prevent freezing, so it works as expected? in XUL <statusbarpanel id="eee_label" tooltip="eee_tooltip" onclick="eee.retrieve_rate(event);"/> Javascript retrieve_rate: function(e) { var ajax = null; ajax = new XMLHttpRequest(); ajax.open('GET', 'http://site.com', false); ajax.onload = function() { if (ajax.status == 200) { var regexp = /blabla/g; var match = regexp.exec(ajax.responseText); while (match != null) { window.dump('Currency: ' + match[1] + ', Rate: ' + match[2] + ', Change: ' + match[3] + "\n"); if(match[1] == "USD") rate_USD = sprintf("%s:%s", match[1], match[2]); if(match[1] == "EUR") rate_EUR = sprintf("%s:%s", match[1], match[2]); if(match[1] == "RUB") rate_RUB = sprintf("%s/%s", match[1], match[2]); match = regexp.exec(ajax.responseText); } var rate = document.getElementById('eee_label'); rate.label = rate_USD + " " + rate_EUR + " " + rate_RUB; } else { } }; ajax.send(); I tried to put window.dump() right after ajax.send() and it dumped in the console also after the request is completed.

  Read the article

• x86 CMP Instruction Difference

  - by Pindatjuh

  Question What is the (non-trivial) difference between the following two x86 instructions? 39 /r CMP r/m32,r32 Compare r32 with r/m32 3B /r CMP r32,r/m32 Compare r/m32 with r32 Background I'm building a Java assembler, which will be used by my compiler's intermediate language to produce Windows-32 executables. Currently I have following code: final ModelBase mb = new ModelBase(); // create new memory model mb.addCode(new Compare(Register.ECX, Register.EAX)); // add code mb.addCode(new Compare(Register.EAX, Register.ECX)); // add code final FileOutputStream fos = new FileOutputStream(new File("test.exe")); mb.writeToFile(fos); fos.close(); To output a valid executable file, which contains two CMP instruction in a TEXT-section. The executable outputted to "text.exe" will do nothing interesting, but that's not the point. The class Compare is a wrapper around the CMP instruction. The above code produces (inspecting with OllyDbg): Address Hex dump Command 0040101F |. 3BC8 CMP ECX,EAX 00401021 |. 3BC1 CMP EAX,ECX The difference is subtle: if I use the 39 byte-opcode: Address Hex dump Command 0040101F |. 39C1 CMP ECX,EAX 00401021 |. 39C8 CMP EAX,ECX Which makes me wonder about their synonymity and why this even exists.

  Read the article

• What is the suggested approach to Syncing/Backing up/Restoring from SQL Server 2008 to SQL Server 20

  - by Eoin Campbell

  I only have SQL Server 2008 (Dev Edition) on my development machine I only have SQL Server 2005 available with my hosting company (and I don't have direct connection access to this database) I'm just wondering what the best approach is for: Getting the initlal DB Structure & Data into production. And keeping any structural changes/data changes in sync in future. As far as I can see... Replication - not an option cos I can't connect to the production DB. Restoring a backup - not an option because as far as I can see, you cannot export a DB from 2008 that is restorable in 2005 (even with the 2008 DB set in 2005 compatibility mode) and it wouldn't make sense to be restoring production over the top of my dev version anyway. Dump all the scripts from my 2008 Database, Revert my Dev to machine from 2008 - 2005, and recreate the database from the scripts, then just use backup & restore to get the initial DB into production, then run scripts through the web panel from that point onwards Dump all the scripts from my 2008 Database and generate the entire 2005 db from scripts in production. then run scripts through the web panel from that point onwards With the last 2 options, I'd probably need to script all the data inserts as well using some tool (which I presume exists on the web) Are there any other possibile solutions that I'm not considering.

  Read the article

• Munging non-printable characters to dots using string.translate()

  - by Jim Dennis

  So I've done this before and it's a surprising ugly bit of code for such a seemingly simple task. The goal is to translate any non-printable character into a . (dot). For my purposes "printable" does exclude the last few characters from string.printable (new-lines, tabs, and so on). This is for printing things like the old MS-DOS debug "hex dump" format ... or anything similar to that (where additional whitespace will mangle the intended dump layout). I know I can use string.translate() and, to use that, I need a translation table. So I use string.maketrans() for that. Here's the best I could come up with: filter = string.maketrans( string.translate(string.maketrans('',''), string.maketrans('',''),string.printable[:-5]), '.'*len(string.translate(string.maketrans('',''), string.maketrans('',''),string.printable[:-5]))) ... which is an unreadable mess (though it does work). From there you can call use something like: for each_line in sometext: print string.translate(each_line, filter) ... and be happy. (So long as you don't look under the hood). Now it is more readable if I break that horrid expression into separate statements: ascii = string.maketrans('','') # The whole ASCII character set nonprintable = string.translate(ascii, ascii, string.printable[:-5]) # Optional delchars argument filter = string.maketrans(nonprintable, '.' * len(nonprintable)) And it's tempting to do that just for legibility. However, I keep thinking there has to be a more elegant way to express this!

  Read the article

• help with Firefox extension

  - by Johnny Grass

  I'm writing a Firefox extension that creates a socket server which will output the active tab's URL when a client makes a connection to it. I have the following code in my javascript file: var serverSocket; function startServer() { var listener = { onSocketAccepted : function(socket, transport) { try { var outputString = gBrowser.currentURI.spec + "\n"; var stream = transport.openOutputStream(0,0,0); stream.write(outputString,outputString.length); stream.close(); } catch(ex2){ dump("::"+ex2); } }, onStopListening : function(socket, status){} }; try { serverSocket = Components.classes["@mozilla.org/network/server-socket;1"] .createInstance(Components.interfaces.nsIServerSocket); serverSocket.init(7055,true,-1); serverSocket.asyncListen(listener); } catch(ex){ dump(ex); } document.getElementById("status").value = "Started"; } startServer(); As it is, it works for multiple tabs in a single window. If I open multiple windows, it ignores the additional windows. I think it is creating a server socket for each window, but since they are using the same port, the additional sockets fail to initialize. I need it to create a server socket when the browser launches and continue running when I close the windows (Mac OS X). As it is, when I close a window but Firefox remains running, the socket closes and I have to restart firefox to get it up an running. How do I go about that?

  Read the article

< Previous Page | 20 21 22 23 24 25 26 27 28 29 30 31  | Next Page >