tls – While importing certificates in keystore, do we treat these like CA root certificates?

When we need to call an internal domain via HTTPS, Java doesn’t allow it because it doesn’t recognize the certificate that those domain web servers are sending (probably because those certificates are self-signed given that these domains are internal to the organization).

In that case, we’re asked to import those certificates. But isn’t the cacert location only there for storing root certificates and not self-signed certificates? I mean, the general procedure is that the certificate issuer’s CA certificate is located in cacert and then the signature is verified using this certificate issuer’s public key. Is the process changed when a self-signed certificate is received?

Or do I have to become my own Certification Authority which would probably require generating a new key pair, then sign the self-signed certificate with my private key, create a CA certificate containing my public key, and then install this certificate in cacerts?

artificial intelligence – How can I treat a problem like a search problem in AI?

I’m a CS student and I’m trying to understand the searching algorithms used in AI.

My problem is that I don’t really understand how to treat a problem like a search problem. I don’t know which would be the first steps for solving it and how shall I choose the right algorithm for that.

For example, I have a problem like that:

n vehicles occupy squares (1, 1) through (n, 1) (i.e., the bottom row) of
an n×n n grid. The vehicles must be moved to the top row but in reverse
order; so the vehicle i that starts in (i, 1) must end up in (n−i+ 1, n). On
each time step, every one of the n vehicles can move one square up, down,
left, or right, or stay put; but if a vehicle stays put, one other adjacent
vehicle (but not more than one) can hop over it. Two vehicles cannot
occupy the same square.

I understood that the start state of each car is the bottom row,
each car has at most five possible moves from any position and if each car has
a 3×3 grid of empty space around it, then all five moves are possible.

Which would be my first steps regarding this problem to solve it like a search problem?

I would be very thankful for any advice!

php – treat cookie collection

Good morning people. I am a beginner in the programming world.

I have the task of adapting a website to the LGPD. For this, a warning must be inserted on the website, in which the user can choose which cookies can be collected.

The site is in .php and was not developed by me. When accessing via Chrome, the browser shows that 4 cookies are used (_ga, _gat, _gid and PHPSESSID). According to my research, cookies are _ga, _gat, _gid for Google Analytics.

Can someone help how to give the user an option, which cookie can be collected by the website or not?

If possible, I need it. As long as the user does not click on "I accept such a cookie", no cookies are collected.

Thanks in advance!

What is the best way to treat anxiety?

Virtual machine – How do VMs and GCs treat objects that still contain active resources but cannot be reached by user code?

I'm building an interpreter in C for a simple programming language.

The interpreter is equipped with a built-in garbage collector. The GC simply marks all objects that are linked from a master (call stack, evaluation stack, loaded modules, etc.) and collects the rest.

I am now writing an extension DLL for the interpreter. The DLL "packs" another C library for graphics (SDL). This library creates objects that represent operating system resources, e.g. B. graphic windows. Now I have to think about how the interpreter and the GC integrate correctly into the "outside world".

In the current situation you could write the following code in my language and it will work fine:

import graphics
window = graphics.new_window()
# ... all the rest

However, the following code is likely to cause problems:

import graphics
graphics.new_window()

Since the result of new_window() will not be saved anywhere, eventually the GC will collect them Window Object. When picking up the Window The object returns the native resources as part of it to the operating system deallocate Implementation called by the GC.

I'm not sure if this is reasonable behavior for a programming language. On the one hand, there is little point in losing the window if we lose the reference to the window.

However, if I remember correctly – in Java (and I assume we can find equivalent examples in most languages), it is common and legal to write code like the following (pseudo-Java):

public void makeWindow() {
    new JFrame();
}

This would create a GUI window that will appear on the screen and remain visible. And as you can see, the JFrame Object is not saved anywhere. However, the GC won't capture it (or at least not the operating system resource JFrame persumebly wraps).

What is the standard way to implement this in a voice VM?

The only approach I can think of right now is that objects that wrap native resources do Not Release these resources when the GC claims them. The only way to release these resources would be to explicitly call the user code at a dispose Method for the object. Which approach is standard in VM implementations?

GUI design – treat foldable devices like a multi-screen user environment? Any research or knowledge that supports the hypothesis?

Although I don't really understand the need for foldable devices, it hasn't stopped phone companies from pushing the boundaries when it comes to defining a "display area" and its possibilities.

Earlier questions about design strategies didn't really resonate with UXSE, since most of our attention is still focused on how we can deal with the differences in screen resolution and aspect ratios, let alone deal with multiple screens.

Given the consensus that we are almost turning ourselves upside down in an age where "mobile first" and "content-is-the-king" dominate most discussions, I think it makes sense to think about it Which unexplored waters impact foldable devices and their effects The interface design is interesting to consider.

My hypothesis is that they are treated like multi-screen devices in terms of user workflow and interactions, but I wonder if there are research or use cases that support this (since I haven't tried this area yet) ,

Plotting – Why does Tube treat this list of triple machine numbers differently than Line?

I have a number of dates that Line but enjoy quite well Tube seems to be causing a tantrum if I deliver the same record. The data:

data = {{-1214.2199935658107`,-848.2705321806565`,-0.00001416666666666664`},{-1244.2463057872262`,-804.5024679750907`,-0.000013333333333333296`},{-1272.6743663132045`,-759.6590618571543`,-0.000012499999999999979`},{-1299.4664556851817`,-713.7981785755134`,-0.000011666666666666634`},{-1324.5865758011587`,-666.978491137754`,-0.000010833333333333317`},{-1348.0004016604767`,-619.2595928877795`,-9.999999999999972`*^-6},{-1369.6752736128424`,-570.7021396907099`,-9.166666666666655`*^-6},{-1389.5802339318311`,-521.3680065458933`,-8.33333333333331`*^-6},{-1407.6861084082525`,-471.32044184944846`,-7.4999999999999655`*^-6},{-1423.9656304860086`,-420.62420257475856`,-6.666666666666648`*^-6},{-1438.3936024494813`,-369.34565482908965`,-5.8333333333333306`*^-6},{-1450.9470855141483`,-317.5528264957635`,-4.999999999999959`*^-6},{-1461.6056085442237`,-265.31540183164884`,-4.1666666666666415`*^-6},{-1470.3513836617653`,-212.70465174468688`,-3.333333333333324`*^-6},{-1477.169516316059`,-159.79329776504858`,-2.4999999999999523`*^-6},{-1482.0481974956165`,-106.65531215558806`,-1.666666666666635`*^-6},{-1484.9788666805996`,-53.3656608828774`,-8.333333333333174`*^-7},{-1485.9563357913094`,-1.0921533706287417`*^-11,0.`},{-1484.9788666806012`,53.36566088285824`,8.333333333333717`*^-7},{-1482.0481974956178`,106.6553121555689`,1.6666666666666891`*^-6},{-1477.1695163160618`,159.79329776502965`,2.5000000000000066`*^-6},{-1470.351383661767`,212.70465174466793`,3.3333333333333782`*^-6},{-1461.6056085442272`,265.3154018316305`,4.166666666666696`*^-6},{-1450.9470855141521`,317.55282649574525`,5.000000000000013`*^-6},{-1438.3936024494853`,369.3456548290715`,5.833333333333385`*^-6},{-1423.9656304860139`,420.62420257474065`,6.666666666666702`*^-6},{-1407.6861084082593`,471.320441849431`,7.50000000000002`*^-6},{-1389.5802339318382`,521.3680065458755`,8.333333333333337`*^-6},{-1369.67527361285`,570.7021396906931`,9.166666666666709`*^-6},{-1348.0004016604855`,619.2595928877626`,0.000010000000000000026`},{-1324.58657580117`,666.9784911377373`,0.000010833333333333344`},{-1299.4664556851928`,713.7981785754989`,0.000011666666666666715`}};

Entered in:

Grid[{{Graphics3D[{
     {Darker[Green, 2/3], Thickness[0.01], 
      Arrowheads[{{0.1}}, Appearance -> "Projected"], Arrow[Tube[data]]}

     }, AlignmentPoint -> Center, AspectRatio -> Automatic, 
    AutomaticImageSize -> False, Axes -> False, AxesEdge -> None, 
    AxesLabel -> None, AxesOrigin -> {1650.`, -1650.`, -0.00025`}, 
    AxesStyle -> {}, Background -> None, 
    BaselinePosition -> Automatic, BaseStyle -> {}, Boxed -> False, 
    BoxRatios -> {3.2`, 3.2`, 6.5`}, BoxStyle -> {}, 
    ClipPlanes -> None, ClipPlanesStyle -> Automatic, 
    ColorOutput -> Automatic, ContentSelectable -> Automatic, 
    ControllerLinking -> Automatic, ControllerMethod -> Automatic, 
    ControllerPath -> Automatic, CoordinatesToolOptions -> Automatic, 
    DisplayFunction -> Identity, Epilog -> {}, FaceGrids -> None, 
    FaceGridsStyle -> {}, FormatType -> TraditionalForm, 
    ImageMargins -> 0.`, ImagePadding -> All, ImageSize -> 500.`, 
    ImageSizeRaw -> Automatic, LabelStyle -> {}, 
    Lighting -> Automatic, Method -> Automatic, PlotLabel -> None, 
    PlotRange -> {{-2475.`, 
       1815.0000000000002`}, {-1815.0000000000002`, 
       2475.`}, {-0.00032500000000000004`, 0.00032500000000000004`}}, 
    PlotRangePadding -> Automatic, PlotRegion -> Automatic, 
    PreserveImageOptions -> Automatic, Prolog -> {}, 
    RotationAction -> "Fit", SphericalRegion -> True, Ticks -> None, 
    TicksStyle -> {}, TouchscreenAutoZoom -> False, 
    ViewAngle -> 0.33632810973764027`, 
    ViewCenter -> {0.5`, 0.5`, 0.5`}, ViewMatrix -> Automatic, 
    ViewPoint -> {-1.9461497767487252`, 1.477527579217831`, 
      2.340814665690469`}, ViewProjection -> Automatic, 
    ViewRange -> All, ViewVector -> Automatic, 
    ViewVertical -> {0.23556268765910476`, -0.24706981260320413`, 
      0.9399291079028442`}], Graphics3D[{
     {Darker[Green, 2/3], Thickness[0.01], 
      Arrowheads[{{0.1}}, Appearance -> "Projected"], Arrow[Line[data]]}

     }, AlignmentPoint -> Center, AspectRatio -> Automatic, 
    AutomaticImageSize -> False, Axes -> False, AxesEdge -> None, 
    AxesLabel -> None, AxesOrigin -> {1650.`, -1650.`, -0.00025`}, 
    AxesStyle -> {}, Background -> None, 
    BaselinePosition -> Automatic, BaseStyle -> {}, Boxed -> False, 
    BoxRatios -> {3.2`, 3.2`, 6.5`}, BoxStyle -> {}, 
    ClipPlanes -> None, ClipPlanesStyle -> Automatic, 
    ColorOutput -> Automatic, ContentSelectable -> Automatic, 
    ControllerLinking -> Automatic, ControllerMethod -> Automatic, 
    ControllerPath -> Automatic, CoordinatesToolOptions -> Automatic, 
    DisplayFunction -> Identity, Epilog -> {}, FaceGrids -> None, 
    FaceGridsStyle -> {}, FormatType -> TraditionalForm, 
    ImageMargins -> 0.`, ImagePadding -> All, ImageSize -> 500.`, 
    ImageSizeRaw -> Automatic, LabelStyle -> {}, 
    Lighting -> Automatic, Method -> Automatic, PlotLabel -> None, 
    PlotRange -> {{-2475.`, 
       1815.0000000000002`}, {-1815.0000000000002`, 
       2475.`}, {-0.00032500000000000004`, 0.00032500000000000004`}}, 
    PlotRangePadding -> Automatic, PlotRegion -> Automatic, 
    PreserveImageOptions -> Automatic, Prolog -> {}, 
    RotationAction -> "Fit", SphericalRegion -> True, Ticks -> None, 
    TicksStyle -> {}, TouchscreenAutoZoom -> False, 
    ViewAngle -> 0.33632810973764027`, 
    ViewCenter -> {0.5`, 0.5`, 0.5`}, ViewMatrix -> Automatic, 
    ViewPoint -> {-1.9461497767487252`, 1.477527579217831`, 
      2.340814665690469`}, ViewProjection -> Automatic, 
    ViewRange -> All, ViewVector -> Automatic, 
    ViewVertical -> {0.23556268765910476`, -0.24706981260320413`, 
      0.9399291079028442`}]}}]

Which gives:
Presentation of the data provided, which shows a problem with tube versus line

Scaling does not solve this problem.

Doctors who treat electromagnetic hypersensitivity

In addition, there is extensive topographical variability in the penetration of EHS and the uncovered side effects. The EHS rate uncovered was higher in Sweden, Germany and Denmark than in the UK, Austria and France. VDU-related manifestations were increasingly common in Scandinavian countries and were more often associated with skin problems than elsewhere in Europe. Side effects, as announced by EHS staff, are of fundamental importance to the general public.

Read more about EMF Free Vacation here.

Spells – Is there a way to temporarily treat a creature as a different arrangement?

Temporarily the only spell I know in Pathfinder 1e Disastrous transformation spell.

If the magic is successful, the test person must also save a will. If this second rescue fails, the creature loses its extraordinary, supernatural, and spell-like abilities, loses its ability to cast spells (if it has the ability), and receives the alignment, special abilities and points of intelligence, wisdom and charisma of its new form instead of its own, It still retains its class and level (or HD), as well as all of its benefits (such as basic attack bonus, basic rescue bonus, and hit points). It retains all class traits (except spellcasting) that are not exceptional, supernatural, or magical abilities.

The big limitation, however, is that it turns into a creature of small stature and 1 HD.