I think I found an Easter egg.

Do you need any response? Would you provide any details?

Are we having an inside joke now or you really don't know? (serious question)

Sorry if I didn't get your joke. Let me know if you have any real questions.

2018.5153.38 IC has the following Easter egg.

Given any method part of whose name is either 'negative" or "positive" , if you create a selection which encompasses that method name, a lightening bolt will appear to emanate from the "e" in the word  "positive" or "negative" and extend south-east, increasing in width, until it hits the vertical line in the editor that  I think is called the hard wrap guide.

Nicely done. 

I just assumed you knew it was there. If you read my first post, it is a joke understandable by whoever put the Easter egg in. Sorry for the miscommunication. 

I'm not aware of this and was not able to reproduce from your description. Please share a video.

Investigating..Appears to be  dependent on the background color. I have ADD3FF. I couldn't reproduce it with colors not very close to that. I couldn't reproduce in  Community at all. I will post a video in a few minutes. It can't be anything but an Easter egg because it happens iff those words are in a method name spelled correctly. It happens anywhere I do as I described.  

The only capture I have is with a phone camera right now. Hard to post that here. Let me see what I can do tonight.

It has to be an EE because it's directly related to the method name and selection state/color and apparently version and platform (windows 7).

No external program could know when I change the name to and from positive (get the effect) to say positAve (effect goes away) then back to positive (the effect returns). Not to mention it works with negative also. Not to mention it happens anywhere on the screen , so it's not, say, my monitor malfunctioning which is what I thought the 1st time I saw it. 

Ask around. A human is clearly behind this and  it's clearly coming form inside the IJ. 

Please upload the video and idea.log (https://intellij-support.jetbrains.com/hc/articles/207241085): https://intellij-support.jetbrains.com/hc/articles/206869619.

My phone is charging (4%) but I will get to it tonight and upload as requested. 

While I am waiting it occurs to me that it IS possible that something else is happening I am not an expert on these matters but see what you think. 

Alternative hypothesis:

My video card has mapped the word "positive" and the word "negative" to some memory inside it Where those words appear as a method, so the formatting is always the same, the same memory is being accessed to paint those words on the screen.  So there are some distinct mapping of graphics card cells to the words "negative" and "positive"  where ever they appear on my screen. Those cells are going bad in some certain way that  somehow involves going bad specifically as they intersect with a certain range of colors- light blue. What I am seeing is my graphics card freaking out  and not an EE courtesy of IJ. 

I don't actually know if all that is technically possible, the caching of specific words in the graphics card memory etc. etc.  I mean.  What I know is what I described  earlier.. 

While I  am  waiting for my phone  I tried to  get inside the head of a dev who would create an EE like this and tried out more words- Tesla and neutral, but got no effect. 

OK i uploaded the log files  and a 22MB video using 

https://uploads.services.jetbrains.com/

Those files names are 

20190305_191452.mp4 (21.8 mb) 100%
to IJ.zip (397 kb)

I accidentally sent two copies of the zipped logs. 

With the video, the Moire interference is quite bad. You have to enlarge the video to full size or you're not going to make anything out. If you enlarge it you can see what I've seen for  a while now at least three four five days or so. 

It has been doing that all day for that time. I was amused when I thought it was an Easter egg. 

The phenomena is as I described. Anywhere I invoked a method with the words positive or negative, the "e" of  those words would emit that distortion when I selected it. This is any file any method with those words in it. It only happened in method invocations and not declarations. So the declarations of those methods did not exhibit the behavior, but their use did. 

Nothing was weird outside of IJ. 

All that made me think it had to be related to the  PSI because it seemed to be sensitive to it, IOW it exhibited  knowledge of the PSI. So of course that's an  Easter egg rather than some weird programming error.

If I had two methods one below the other I got two identical electrical bolts. If I changed the name by refactoring it went away. If I created a new inner class with a method named blahBlahBlahPositive (or negative), then invocations of THOSE methods exhibited electrical "discharge" of exactly the same type wherever I invoked them . It wasn't local to any particular area of my screen or particular  file or code block  or anything else. I was only about the invocation point of any method whatsoever with those words in it. 

Now I am thinking it is something going on with my graphics card which is also how it first struck me. I was fiddling with git and now when I go back I can't make it happen again. 

Sorry to post an apparently weird post to the forum- it was very clever in the context I assumed was  prevailing- an EE you all knew about and were waiting for someone to report. 

This is really all I know. I am glad I got the shot of it I did. If it happens again I will grab it. My screenshots wouldn't  capture it at all, probably because it was flashing on and off very quickly.  May just not be an IJ thing if no one claims it. That's all I've got.   

...and just now the freak show is back on. I have two good videos of just what I am talking about. I will upload them now. 

In the first you can see multiple discharges from multiple methods. 

Int he second I create a class with three methods , two of which have effected words and one of which has the effected words replaced with the word "neutral". 

I then invoke all three and you can see the following:

the invocations with positive and negative are firing the discharge.

The invocation with the word neutral, which is right between them, is not. 

The declarations of the exact same methods, which uses the  same font and by the alternative hypothesis might be exhibiting the phenomena, is not doing anything. 

The whole thing is very weird. 

The file is declaration and  invocation sent to the same place. 

In this video you can  see the following-

1) multiple discharging from anywhere positive or negative appears in a method invocation, emanating from the "e" in the way described earlier. . 

2) The creation of an ad-hoc class, MyBSClass,  randomly in the file and specifically for the purpose of creating three methods myPositiveMethod, myNegativeMethod and myNeutralMethod.

3) The declaration of these methods does not invoke the phenomena despite the identity of the Strings involved.

4) however, the invocation of the methods does induce the phenomena

5) except for the method name myNeutralMethod which doesn't on account of it's name. 

I can't make the video any bigger than this or I can't get it off my phone to you (25 MB limit) 

I can do other experiments (and have) but it's just all boils down to what I originally described. 

I'll turn off the computer later tomorrow to se if it clears anything up (I don't think it actually does.. can't remember).

I am thinking you would know if it was you so it's just very weird at this point.  

It's certainly not an easter egg, looks like an issue with your video card, driver or display. Could be some hardware bug triggered by a certain combination of colors.

I've never seen anything like that in 17 years of using IntelliJ IDEA.

I don't see a link to the video. The only link I found points to the upload portal.

Mark, the video was uploaded privately for JetBrains team only.

That's a shame. I'm really keen at identifying details and graphics glitches and became interested in this.

OK thanks all wrapped up then. 

Serge if you want to share the video with Mark you have our permission. 

Couple of updates worth mentioning

Changing the font and background color embellishments  of style associated with method declarations so they are exactly-exactly the same as method invocations did NOT cause it to happen with method declarations. 

Restarting the computer did NOT change anything, That's not inconsistent with the alternative, er, only remaining  hypothesis since the computer could be making exactly the same decisions all the way down resulting in exactly the same output when given exactly the same input- the IJ project.

New form of alternative hypothesis is: somehow a graphics card glitch is bleeding all the way through all the layers of abstractions which exist between graphics memory and the  PSI and becoming "involved" with the PSI and my code variable names. It's possible. 

All computers'  behavior is really  nothing but electrons being refreshed in transistors many times a second. There is literally nothing else from start to finish. Your computer is less like an object and more like a stream- of electrons.  All other "things" -programming languages, registers, images on screen- are just  illusions we call  abstractions.  We try  to design parts which control  those electrons so the sum total of their presence or absence is predictable and  makes sense to us. Despite all this, at any time, the "walls" of those abstractions could be breached in ways whose precise moment to moment causality is  practically incomprehensible and whose reason is inscrutable.  That's what the top-tier espionage  hacks try for and sometimes  succeed in doing. When you get hacked, and this is not an instance of that, it looks and feels like magic, like something physically impossible just happened. The truth is the only magic or illusion is the one you took to be real and final - the layers of abstraction. 

It's entirely  possible that when one part of one  abstraction at one layer  breaks down , it  becomes involved in the other layers which are still intact in a way  which looks "meaningful" to us and in fact displays apparent "knowledge" of those layers, in this case the PSI. It's a freak occurrence.

The fact that the words positive  and negative came to be associated with a "lightening bolt" is just a freak coincidence on top of the previous freak coincidence which itself meant nothing until it intersected with the semantics I assigned to it, which was in turn borne of  my awareness of the programming  practice of "Easter eggs" and also my image  of the programmers at IJ  to whom  I attribute the properties: great subtlety, great technical capability and great playfulness. If this had happened in Word, I wouldn't  have posted at the Word forum, believe me. 

Last post . Just still hashing  this out to my own satisfaction. 

The way this "seems"  is a breakdown at one level hit a kind of unlikely semantic bullseye from a mile away with a bow and arrow.  It only seems that way because the end result is so freaky.  But statistically, that doesn't take into account the huge number of not-realized events which would have qualified as just as freaky. All of those targets were missed. The number of those events  is as large as the pool of  coherent narratives  or semantics we can dream up when something like this happens. That pool is vast. 

What looks like a freak occurrence hitting  an unlikely  target- the lightening bolt emanating  from words associated with electricity-  (what are the odds??!!) - is really more like one  occurrence -among trillions of occurrences-  slowly drifting over a vast sea of potential meaning, looking for somewhere, anywhere to splash down safely and thus become a Freak Occurrence. It might happen. The specific final form is indeed freaky.

Freaky things are, in fact, statistically unlikely, but not that unlikely given the vast number of events which are generated any of which may indeed chance upon a safe landing in the Sea of Freak.  

Mark, since I've got the permission to share the video, you can find it here if you are curious: https://youtu.be/1rzgrdlD_IU.

To me it looks like a display issue similar to those when the display is set to work in the FAST or overdrive/overclocked mode. I've seen some weird color banding/flickering problems on DELL displays when they are set to FAST response time (gaming) mode.

Does the issue go away if you disable the hard wrap guide?

Serge,

 I read your question. It's intermittent and not doing it right now. I will reply when it gives me a chance to test it out. 

WRT to FAST display mode AFAIK nothing like that is setup .

I agree the visuals look like a simple graphics card issue, clearly, but its apparent interaction with the PSI elements is what makes it weird. 

I wonder what will happen when you record your screen through screen recording software like OBS? It will at least determine if it's a glitch in the rendering pipeline (software) or the video signal generator (hardware).

I will look at the video as soon as I get the chance.

Serge: the answer is no, hard wrap off makes no difference. 

Mark: I tried that but it didn't capture it. I don't  know why. 

I can confirm today that anywhere I have a method with the name positive (or negative) in it and I highlight that method, it is doing that.  I have restarted my computer a number of times now. 

Just another interesting tidbit- the flashes themselves are  not simultaneous copies of each other. So if a .gif were running in a loop, you'd eventually notice that two out-of sync copies running at the same time were, in fact, copies of each other, just running out of sync. It's not like that. 

Another thing is- they are strongly "aware" of hard wrap guide in the intellij editor. They extend precisely to it, getting wider on the way, then stop dead at it. 

 I am also very curious about what chain of conceivable events could possibly result in this. The fact that it's not happening anywhere but IJ and the fact that it's "hard wrap aware" and "psi aware" and that it persists over reboot and also that it is sensitive to the very word in the identifiers I use makes the whole thing very very weird. If you can think of a clever experiment which would eliminate possibilities, I will run it. The ghost is sometimes intermittent and the ghost buster is busy, so they  would have  to coordinate their schedules of course.  

Not that I need to say it, but there is nothing either illegal or national security  sensitive on this computer, so if it's a persistent hack of some kind letting a tell slip, that  dog is barking up a very wrong tree.  

Mark: If it continues I'll try to isolate the following variables this weekend and see if I can bring this down - the variable  name,  variable language(?!!!),   IJ project, IJ edition, monitor, graphics card. 

Things you can try:

1. Record using OBS.

2. Change `i` in positive to `l`.

3. Take a screenshot, paste in photoshop, see if same happens.

3a. change pixels in the image and try to find a link to image and distortions.

4. Take high quality photo, split to RGB, see if distortions are exclusive to the green channel.

For anyone interested, I was not able to look at this this weekend but next weekend is clear. 

The working plan is - everything Mark suggests and also

variable names , file , project, IJ version, font, language, graphics card / port , monitor, cable  and computer. I can vary all these individually. My sense of it now is it's always happening but I only see it in a certain narrow color,s which gives a lot of credence to what Mark said- it's some part of something involved  with   RGB  rendering phase. I'll try to get better video. of it and post o YouTube, I could not get OBS to capture it but I'll give it another go.

This really looks like a monitor/cable issue, so you will not be able to capture it by recording the screen using OBS or other similar tools.