sharepoint online – Exception calling “ExecuteQuery” with “0” argument(s): “The underlying connection was closed: An unexpected error occurred on a send-SPO

sharepoint online – Exception calling “ExecuteQuery” with “0” argument(s): “The underlying connection was closed: An unexpected error occurred on a send-SPO – SharePoint Stack Exchange

macos – Is there any MacBook-supported filesystem that will not do a scan every time its underlying external HDD gets unplugged without eject?

Currently, with ExFAT filesystem on an external HDD connected to a MacBook Pro I experience very long scan times (proportional to the size of the HDD, several TBs in this case; MacOS is used here) whenever I plug the drive after it was accidentally unplugged without ejecting the drive first.
While I understand the reason behind it, it is sometimes unacceptable to wait for hours before I can start using it again.

Therefore I am looking for filesystems that wouldn’t render the drive unusable for hours whenever that happens.

Any suggestion is appreciated, the internet yields no immediate solutions/answers, and I would really like to avoid answering myself by testing filesystems – if this kind of info already exists somewhere out there.

Wrapping RestTemplate effectivly changing the underlying API

I have this case at work where a collegue has wrapped RestTemplate and HttpRequest/responseEntity with his own set of classes presuming it is very nice to provide fluent API which spring rest template does not provide due to its age. While on a moderate scale this probably is a good idea it reminds me very much of not so far away future between 2000 2006 when developers were predefining pretty much everything building their own shared libraries and frameworks.

Why this is bad idea ?

sharepoint online – Connect-PnPOnline through error “The underlying connection was closed: An unexpected error occurred on a receive.”

Stack Exchange Network


Stack Exchange network consists of 176 Q&A communities including Stack Overflow, the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Visit Stack Exchange

np complete – Difference longest path problem and underlying decision problem

I am studying the longest path problem with the final objective to show that it is NP-complete. On wikipedia I read that the problem itself is NP-hard but the underlying decision problem is NP-complete.

I have some trouble understanding the difference between the two though. How are they not the same? I read in another post on CS that decision problems are conceptually easier to understand. But does this mean there are solutions to this problem with NP-hard complexity?

As I understood from my professor a graph problem is in NP if there are exponentially many paths to test in terms of the graph size. As you might notice, this definition does not talk about possible solutions/algorithms.

Also, all the references I found only talk about solutions to the problem, but don’t give any formal definition. Quoting wikipedia as a source for my work looks kind of messy. So if anybody knows a paper that nicely describes the problem formally, any tips are welcome.

drop down list – Should underlying content be disabled when dropdown menu or custom select control is opened?

As the title of the question, when implementing the drop-down menu or custom select control, should the underlying content rendered on page be disabled or made inaccessible as long as drop-down is open?

Further, should the focus be trapped till the menu is closed?

How does electrum interact with the underlying bitcoind service?

I am a bit confused regarding the bitcoind peers and Electrum X peers.

From what I understand, the electrum X protocol is built on top of the bitcoin blockchain, but I cannot quite wrap my head around on how exactly they interact.

I get it that electrum needs to have access to a bitcoind process in order to sync up its database, but what happens after the sync? Does the electrum client receive notifications about new transactions from other electrum peers, or does it still use underlying bitcoind mempool? Or both?

Can somebody explain on how exactly these 2 services interact?

mysql – Understand the underlying logic of Sakila DB

I’m working with Sakila database, trying to find which film is instock in store 1. However, before going to the syntax, I have basic question about the database first.

  1. If a movie is rented out, I think it’s captured in the rental Table. However, if it has been returned, would it be captured in rental table or will be deleted?
  • If it’s captured in ‘rental table’, then how do we know which movie has been returned and which movie has not been returned? I just observe the table, and it looks like the ‘return date’ are all BEFORE ‘last update’. does that mean all movies have been returned? (refer to the picture)
  • If it is NOT captured in ‘rental table’, then which Syntax does the job of ‘deleting the record’?
  1. What are these syntax for? (Rental table) what does KEY for?
    KEY idx_fk_inventory_id (inventory_id),
    KEY idx_fk_customer_id (customer_id),
    KEY idx_fk_staff_id (staff_id),

Thanks so much

enter image description here

graphics – Why is there a discrepency between JoinedCurve/FilledCurve and the underlying BSplineCurve segments?

This may be related to How to discretize a BezierCurve?, but this question deals with BSplineCurves with specific SplineWeights, so I don’t think the answers there will help here.


Background

I am using version 11.3.0.0 (on Mac OS 10.11.5).

I recently wrote an Arc function that takes the same arguments as Circle. This spits out a list of degree 2 BSplineCurves with the appropriate SplineWeights to generate pieces of a circle. I did this so that the last piece can be wrapped in an Arrow to make circular-arc arrows.

I also wanted to use JoinedCurve and FilledCurve with the arcs, which cannot be done with Circle.

The Problem

The code

segments = {
BSplineCurve({{1, 0}, {1, 1}, {0, 1}}, SplineWeights -> {1, 1/Sqrt(2), 1}),
BSplineCurve({{0, 1}, {-1, 1}, {-1, 0}}, SplineWeights -> {1, 1/Sqrt(2), 1})
};
Graphics({{Red,segments},JoinedCurve(segments)})

produces the output

JoinedCurve bug

The red curve is drawn first and seems to be correct. The black curve is drawn second and overlays the first segment properly; however, the second segment doesn’t quite follow the red circle. Ideally, the black curve should completely obscure the red curve.

I was thinking that the problem might be that that JoinedCurve was trying to use a cubic spline to try to match the quadratic rational spline; however, then the first segment would not overlay so precisely (a cubic spline cannot exactly trace an arc of a circle unless it employs the proper weights).

The same problem is displayed by FilledCurve:

segments = {
BSplineCurve({{1/4, -(3/4)}, {1, -(3/4)}, {1, 0}}, SplineWeights -> {1, 1/Sqrt(2), 1}),
BSplineCurve({{1, 0}, {1, 3/4}, {1/4, 3/4}}, SplineWeights -> {1, 1/Sqrt(2), 1}),
Line({{1/4, 3/4}, {-(1/4), 3/4}}),
BSplineCurve({{-(1/4), 3/4}, {-1, 3/4}, {-1, 0}}, SplineWeights -> {1, 1/Sqrt(2), 1}),
BSplineCurve({{-1, 0}, {-1, -(3/4)}, {-(1/4), -(3/4)}}, SplineWeights -> {1, 1/Sqrt(2), 1}),
Line({{-(1/4), -(3/4)}, {1/4, -(3/4)}})
};
Graphics({{Red, segments}, FilledCurve(segments)})

enter image description here

Does anyone know what is going on here, and whether this persists in newer versions as well.

Do differences between ATT and Intel formats of assembly languages come from differences between their underlying machine languages?

From Computer Systems: a Programmer’s Perspective, about assembly languages:

We see that the Intel and ATT formats differ in the following ways:

  • The Intel code omits the size designation suffixes. We see instruction push and mov instead of pushq and movq.
  • The Intel code omits the ‘%’ character in front of register names, using rbx instead of %rbx.
  • The Intel code has a different way of describing locations in memory—for example, QWORD PTR (rbx) rather than (%rbx).
  • Instructions with multiple operands list them in the reverse order. This can be very confusing when switching between the two formats.

There is close correspondence between assembly languages and machine languages (i.e. ISA).

Do the above differences between ATT and Intel formats of assembly languages come from some differences between their underlying machine languages?
Or do the differences between ATT and Intel formats of assembly languages only exist at the level of assembly languages, i.e. is it normal that both formats may be based on the same machine languages?

Thanks.

DreamProxies - Cheapest USA Elite Private Proxies 100 Private Proxies 200 Private Proxies 400 Private Proxies 1000 Private Proxies 2000 Private Proxies ExtraProxies.com - Buy Cheap Private Proxies Buy 50 Private Proxies Buy 100 Private Proxies Buy 200 Private Proxies Buy 500 Private Proxies Buy 1000 Private Proxies Buy 2000 Private Proxies ProxiesLive Proxies-free.com New Proxy Lists Every Day Proxies123